import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        AuthApi apiInstance = new AuthApi();
        AuthChangePasswordRequest authChangePasswordRequest = ; // AuthChangePasswordRequest | 

        try {
            auth_change_password_200_response result = apiInstance.authChangePassword(authChangePasswordRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authChangePassword");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AuthChangePasswordRequest authChangePasswordRequest = new AuthChangePasswordRequest(); // AuthChangePasswordRequest | 

try {
    final result = await api_instance.authChangePassword(authChangePasswordRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->authChangePassword: $e\n');
}

import org.openapitools.client.api.AuthApi;

public class AuthApiExample {
    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();
        AuthChangePasswordRequest authChangePasswordRequest = ; // AuthChangePasswordRequest | 

        try {
            auth_change_password_200_response result = apiInstance.authChangePassword(authChangePasswordRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authChangePassword");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
AuthApi *apiInstance = [[AuthApi alloc] init];
AuthChangePasswordRequest *authChangePasswordRequest = ; // 

// Change password
[apiInstance authChangePasswordWith:authChangePasswordRequest
              completionHandler: ^(auth_change_password_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.AuthApi()
var authChangePasswordRequest = ; // {AuthChangePasswordRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.authChangePassword(authChangePasswordRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class authChangePasswordExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new AuthApi();
            var authChangePasswordRequest = new AuthChangePasswordRequest(); // AuthChangePasswordRequest | 

            try {
                // Change password
                auth_change_password_200_response result = apiInstance.authChangePassword(authChangePasswordRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthApi.authChangePassword: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthApi();
$authChangePasswordRequest = ; // AuthChangePasswordRequest | 

try {
    $result = $api_instance->authChangePassword($authChangePasswordRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->authChangePassword: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthApi->new();
my $authChangePasswordRequest = WWW::OPenAPIClient::Object::AuthChangePasswordRequest->new(); # AuthChangePasswordRequest | 

eval {
    my $result = $api_instance->authChangePassword(authChangePasswordRequest => $authChangePasswordRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthApi->authChangePassword: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.AuthApi()
authChangePasswordRequest =  # AuthChangePasswordRequest | 

try:
    # Change password
    api_response = api_instance.auth_change_password(authChangePasswordRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthApi->authChangePassword: %s\n" % e)

extern crate AuthApi;

pub fn main() {
    let authChangePasswordRequest = ; // AuthChangePasswordRequest

    let mut context = AuthApi::Context::default();
    let result = client.authChangePassword(authChangePasswordRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        AuthApi apiInstance = new AuthApi();
        LoginRequest loginRequest = ; // LoginRequest | 

        try {
            SessionResponse result = apiInstance.authLogin(loginRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authLogin");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final LoginRequest loginRequest = new LoginRequest(); // LoginRequest | 

try {
    final result = await api_instance.authLogin(loginRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->authLogin: $e\n');
}

import org.openapitools.client.api.AuthApi;

public class AuthApiExample {
    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();
        LoginRequest loginRequest = ; // LoginRequest | 

        try {
            SessionResponse result = apiInstance.authLogin(loginRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authLogin");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
AuthApi *apiInstance = [[AuthApi alloc] init];
LoginRequest *loginRequest = ; // 

// User login
[apiInstance authLoginWith:loginRequest
              completionHandler: ^(SessionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.AuthApi()
var loginRequest = ; // {LoginRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.authLogin(loginRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class authLoginExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new AuthApi();
            var loginRequest = new LoginRequest(); // LoginRequest | 

            try {
                // User login
                SessionResponse result = apiInstance.authLogin(loginRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthApi.authLogin: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthApi();
$loginRequest = ; // LoginRequest | 

try {
    $result = $api_instance->authLogin($loginRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->authLogin: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthApi->new();
my $loginRequest = WWW::OPenAPIClient::Object::LoginRequest->new(); # LoginRequest | 

eval {
    my $result = $api_instance->authLogin(loginRequest => $loginRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthApi->authLogin: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.AuthApi()
loginRequest =  # LoginRequest | 

try:
    # User login
    api_response = api_instance.auth_login(loginRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthApi->authLogin: %s\n" % e)

extern crate AuthApi;

pub fn main() {
    let loginRequest = ; // LoginRequest

    let mut context = AuthApi::Context::default();
    let result = client.authLogin(loginRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        AuthApi apiInstance = new AuthApi();

        try {
            apiInstance.authLogout();
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authLogout");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.authLogout();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->authLogout: $e\n');
}

import org.openapitools.client.api.AuthApi;

public class AuthApiExample {
    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();

        try {
            apiInstance.authLogout();
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authLogout");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
AuthApi *apiInstance = [[AuthApi alloc] init];

// User logout
[apiInstance authLogoutWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.AuthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.authLogout(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class authLogoutExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new AuthApi();

            try {
                // User logout
                apiInstance.authLogout();
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthApi.authLogout: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthApi();

try {
    $api_instance->authLogout();
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->authLogout: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthApi->new();

eval {
    $api_instance->authLogout();
};
if ($@) {
    warn "Exception when calling AuthApi->authLogout: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.AuthApi()

try:
    # User logout
    api_instance.auth_logout()
except ApiException as e:
    print("Exception when calling AuthApi->authLogout: %s\n" % e)

extern crate AuthApi;

pub fn main() {

    let mut context = AuthApi::Context::default();
    let result = client.authLogout(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        AuthApi apiInstance = new AuthApi();

        try {
            UserPublicResponse result = apiInstance.authMe();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authMe");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.authMe();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->authMe: $e\n');
}

import org.openapitools.client.api.AuthApi;

public class AuthApiExample {
    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();

        try {
            UserPublicResponse result = apiInstance.authMe();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authMe");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
AuthApi *apiInstance = [[AuthApi alloc] init];

// Get current user
[apiInstance authMeWithCompletionHandler: 
              ^(UserPublicResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.AuthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.authMe(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class authMeExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new AuthApi();

            try {
                // Get current user
                UserPublicResponse result = apiInstance.authMe();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthApi.authMe: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthApi();

try {
    $result = $api_instance->authMe();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->authMe: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthApi->new();

eval {
    my $result = $api_instance->authMe();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthApi->authMe: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.AuthApi()

try:
    # Get current user
    api_response = api_instance.auth_me()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthApi->authMe: %s\n" % e)

extern crate AuthApi;

pub fn main() {

    let mut context = AuthApi::Context::default();
    let result = client.authMe(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.AuthApi;

import java.io.File;
import java.util.*;

public class AuthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        AuthApi apiInstance = new AuthApi();

        try {
            SessionResponse result = apiInstance.authRefresh();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authRefresh");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.authRefresh();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->authRefresh: $e\n');
}

import org.openapitools.client.api.AuthApi;

public class AuthApiExample {
    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();

        try {
            SessionResponse result = apiInstance.authRefresh();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authRefresh");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
AuthApi *apiInstance = [[AuthApi alloc] init];

// Refresh session
[apiInstance authRefreshWithCompletionHandler: 
              ^(SessionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.AuthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.authRefresh(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class authRefreshExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new AuthApi();

            try {
                // Refresh session
                SessionResponse result = apiInstance.authRefresh();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthApi.authRefresh: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthApi();

try {
    $result = $api_instance->authRefresh();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling AuthApi->authRefresh: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AuthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthApi->new();

eval {
    my $result = $api_instance->authRefresh();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AuthApi->authRefresh: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.AuthApi()

try:
    # Refresh session
    api_response = api_instance.auth_refresh()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthApi->authRefresh: %s\n" % e)

extern crate AuthApi;

pub fn main() {

    let mut context = AuthApi::Context::default();
    let result = client.authRefresh(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        BulkResourceAllocationRequest bulkResourceAllocationRequest = ; // BulkResourceAllocationRequest | 

        try {
            BulkResourceAllocationResponse result = apiInstance.allocateBulkResources(bulkResourceAllocationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#allocateBulkResources");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkResourceAllocationRequest bulkResourceAllocationRequest = new BulkResourceAllocationRequest(); // BulkResourceAllocationRequest | 

try {
    final result = await api_instance.allocateBulkResources(bulkResourceAllocationRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->allocateBulkResources: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        BulkResourceAllocationRequest bulkResourceAllocationRequest = ; // BulkResourceAllocationRequest | 

        try {
            BulkResourceAllocationResponse result = apiInstance.allocateBulkResources(bulkResourceAllocationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#allocateBulkResources");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
BulkResourceAllocationRequest *bulkResourceAllocationRequest = ; // 

// Allocate bulk operation resources
[apiInstance allocateBulkResourcesWith:bulkResourceAllocationRequest
              completionHandler: ^(BulkResourceAllocationResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var bulkResourceAllocationRequest = ; // {BulkResourceAllocationRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.allocateBulkResources(bulkResourceAllocationRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class allocateBulkResourcesExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var bulkResourceAllocationRequest = new BulkResourceAllocationRequest(); // BulkResourceAllocationRequest | 

            try {
                // Allocate bulk operation resources
                BulkResourceAllocationResponse result = apiInstance.allocateBulkResources(bulkResourceAllocationRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.allocateBulkResources: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$bulkResourceAllocationRequest = ; // BulkResourceAllocationRequest | 

try {
    $result = $api_instance->allocateBulkResources($bulkResourceAllocationRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->allocateBulkResources: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $bulkResourceAllocationRequest = WWW::OPenAPIClient::Object::BulkResourceAllocationRequest->new(); # BulkResourceAllocationRequest | 

eval {
    my $result = $api_instance->allocateBulkResources(bulkResourceAllocationRequest => $bulkResourceAllocationRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->allocateBulkResources: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
bulkResourceAllocationRequest =  # BulkResourceAllocationRequest | 

try:
    # Allocate bulk operation resources
    api_response = api_instance.allocate_bulk_resources(bulkResourceAllocationRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->allocateBulkResources: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let bulkResourceAllocationRequest = ; // BulkResourceAllocationRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.allocateBulkResources(bulkResourceAllocationRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        BulkAnalyticsRequest bulkAnalyticsRequest = ; // BulkAnalyticsRequest | 

        try {
            BulkAnalyticsResponse result = apiInstance.bulkAnalyzeDomains(bulkAnalyticsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkAnalyzeDomains");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkAnalyticsRequest bulkAnalyticsRequest = new BulkAnalyticsRequest(); // BulkAnalyticsRequest | 

try {
    final result = await api_instance.bulkAnalyzeDomains(bulkAnalyticsRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->bulkAnalyzeDomains: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        BulkAnalyticsRequest bulkAnalyticsRequest = ; // BulkAnalyticsRequest | 

        try {
            BulkAnalyticsResponse result = apiInstance.bulkAnalyzeDomains(bulkAnalyticsRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkAnalyzeDomains");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
BulkAnalyticsRequest *bulkAnalyticsRequest = ; // 

// Bulk domain analysis
[apiInstance bulkAnalyzeDomainsWith:bulkAnalyticsRequest
              completionHandler: ^(BulkAnalyticsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var bulkAnalyticsRequest = ; // {BulkAnalyticsRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.bulkAnalyzeDomains(bulkAnalyticsRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class bulkAnalyzeDomainsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var bulkAnalyticsRequest = new BulkAnalyticsRequest(); // BulkAnalyticsRequest | 

            try {
                // Bulk domain analysis
                BulkAnalyticsResponse result = apiInstance.bulkAnalyzeDomains(bulkAnalyticsRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.bulkAnalyzeDomains: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$bulkAnalyticsRequest = ; // BulkAnalyticsRequest | 

try {
    $result = $api_instance->bulkAnalyzeDomains($bulkAnalyticsRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->bulkAnalyzeDomains: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $bulkAnalyticsRequest = WWW::OPenAPIClient::Object::BulkAnalyticsRequest->new(); # BulkAnalyticsRequest | 

eval {
    my $result = $api_instance->bulkAnalyzeDomains(bulkAnalyticsRequest => $bulkAnalyticsRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->bulkAnalyzeDomains: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
bulkAnalyticsRequest =  # BulkAnalyticsRequest | 

try:
    # Bulk domain analysis
    api_response = api_instance.bulk_analyze_domains(bulkAnalyticsRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->bulkAnalyzeDomains: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let bulkAnalyticsRequest = ; // BulkAnalyticsRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.bulkAnalyzeDomains(bulkAnalyticsRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        BulkDomainGenerationRequest bulkDomainGenerationRequest = ; // BulkDomainGenerationRequest | 

        try {
            BulkGenerationResponse result = apiInstance.bulkGenerateDomains(bulkDomainGenerationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkGenerateDomains");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkDomainGenerationRequest bulkDomainGenerationRequest = new BulkDomainGenerationRequest(); // BulkDomainGenerationRequest | 

try {
    final result = await api_instance.bulkGenerateDomains(bulkDomainGenerationRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->bulkGenerateDomains: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        BulkDomainGenerationRequest bulkDomainGenerationRequest = ; // BulkDomainGenerationRequest | 

        try {
            BulkGenerationResponse result = apiInstance.bulkGenerateDomains(bulkDomainGenerationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkGenerateDomains");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
BulkDomainGenerationRequest *bulkDomainGenerationRequest = ; // 

// Bulk domain generation
[apiInstance bulkGenerateDomainsWith:bulkDomainGenerationRequest
              completionHandler: ^(BulkGenerationResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var bulkDomainGenerationRequest = ; // {BulkDomainGenerationRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.bulkGenerateDomains(bulkDomainGenerationRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class bulkGenerateDomainsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var bulkDomainGenerationRequest = new BulkDomainGenerationRequest(); // BulkDomainGenerationRequest | 

            try {
                // Bulk domain generation
                BulkGenerationResponse result = apiInstance.bulkGenerateDomains(bulkDomainGenerationRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.bulkGenerateDomains: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$bulkDomainGenerationRequest = ; // BulkDomainGenerationRequest | 

try {
    $result = $api_instance->bulkGenerateDomains($bulkDomainGenerationRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->bulkGenerateDomains: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $bulkDomainGenerationRequest = WWW::OPenAPIClient::Object::BulkDomainGenerationRequest->new(); # BulkDomainGenerationRequest | 

eval {
    my $result = $api_instance->bulkGenerateDomains(bulkDomainGenerationRequest => $bulkDomainGenerationRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->bulkGenerateDomains: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
bulkDomainGenerationRequest =  # BulkDomainGenerationRequest | 

try:
    # Bulk domain generation
    api_response = api_instance.bulk_generate_domains(bulkDomainGenerationRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->bulkGenerateDomains: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let bulkDomainGenerationRequest = ; // BulkDomainGenerationRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.bulkGenerateDomains(bulkDomainGenerationRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        BulkDNSValidationRequest bulkDNSValidationRequest = ; // BulkDNSValidationRequest | 

        try {
            BulkValidationResponse result = apiInstance.bulkValidateDNS(bulkDNSValidationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkValidateDNS");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkDNSValidationRequest bulkDNSValidationRequest = new BulkDNSValidationRequest(); // BulkDNSValidationRequest | 

try {
    final result = await api_instance.bulkValidateDNS(bulkDNSValidationRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->bulkValidateDNS: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        BulkDNSValidationRequest bulkDNSValidationRequest = ; // BulkDNSValidationRequest | 

        try {
            BulkValidationResponse result = apiInstance.bulkValidateDNS(bulkDNSValidationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkValidateDNS");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
BulkDNSValidationRequest *bulkDNSValidationRequest = ; // 

// Bulk DNS validation
[apiInstance bulkValidateDNSWith:bulkDNSValidationRequest
              completionHandler: ^(BulkValidationResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var bulkDNSValidationRequest = ; // {BulkDNSValidationRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.bulkValidateDNS(bulkDNSValidationRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class bulkValidateDNSExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var bulkDNSValidationRequest = new BulkDNSValidationRequest(); // BulkDNSValidationRequest | 

            try {
                // Bulk DNS validation
                BulkValidationResponse result = apiInstance.bulkValidateDNS(bulkDNSValidationRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.bulkValidateDNS: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$bulkDNSValidationRequest = ; // BulkDNSValidationRequest | 

try {
    $result = $api_instance->bulkValidateDNS($bulkDNSValidationRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->bulkValidateDNS: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $bulkDNSValidationRequest = WWW::OPenAPIClient::Object::BulkDNSValidationRequest->new(); # BulkDNSValidationRequest | 

eval {
    my $result = $api_instance->bulkValidateDNS(bulkDNSValidationRequest => $bulkDNSValidationRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->bulkValidateDNS: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
bulkDNSValidationRequest =  # BulkDNSValidationRequest | 

try:
    # Bulk DNS validation
    api_response = api_instance.bulk_validate_dns(bulkDNSValidationRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->bulkValidateDNS: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let bulkDNSValidationRequest = ; // BulkDNSValidationRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.bulkValidateDNS(bulkDNSValidationRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        BulkHTTPValidationRequest bulkHTTPValidationRequest = ; // BulkHTTPValidationRequest | 

        try {
            BulkValidationResponse result = apiInstance.bulkValidateHTTP(bulkHTTPValidationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkValidateHTTP");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkHTTPValidationRequest bulkHTTPValidationRequest = new BulkHTTPValidationRequest(); // BulkHTTPValidationRequest | 

try {
    final result = await api_instance.bulkValidateHTTP(bulkHTTPValidationRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->bulkValidateHTTP: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        BulkHTTPValidationRequest bulkHTTPValidationRequest = ; // BulkHTTPValidationRequest | 

        try {
            BulkValidationResponse result = apiInstance.bulkValidateHTTP(bulkHTTPValidationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#bulkValidateHTTP");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
BulkHTTPValidationRequest *bulkHTTPValidationRequest = ; // 

// Bulk HTTP validation
[apiInstance bulkValidateHTTPWith:bulkHTTPValidationRequest
              completionHandler: ^(BulkValidationResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var bulkHTTPValidationRequest = ; // {BulkHTTPValidationRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.bulkValidateHTTP(bulkHTTPValidationRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class bulkValidateHTTPExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var bulkHTTPValidationRequest = new BulkHTTPValidationRequest(); // BulkHTTPValidationRequest | 

            try {
                // Bulk HTTP validation
                BulkValidationResponse result = apiInstance.bulkValidateHTTP(bulkHTTPValidationRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.bulkValidateHTTP: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$bulkHTTPValidationRequest = ; // BulkHTTPValidationRequest | 

try {
    $result = $api_instance->bulkValidateHTTP($bulkHTTPValidationRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->bulkValidateHTTP: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $bulkHTTPValidationRequest = WWW::OPenAPIClient::Object::BulkHTTPValidationRequest->new(); # BulkHTTPValidationRequest | 

eval {
    my $result = $api_instance->bulkValidateHTTP(bulkHTTPValidationRequest => $bulkHTTPValidationRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->bulkValidateHTTP: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
bulkHTTPValidationRequest =  # BulkHTTPValidationRequest | 

try:
    # Bulk HTTP validation
    api_response = api_instance.bulk_validate_http(bulkHTTPValidationRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->bulkValidateHTTP: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let bulkHTTPValidationRequest = ; // BulkHTTPValidationRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.bulkValidateHTTP(bulkHTTPValidationRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();

        try {
            array[campaigns_bulk_operations_list_200_response_inner] result = apiInstance.campaignsBulkOperationsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsBulkOperationsList");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.campaignsBulkOperationsList();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsBulkOperationsList: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();

        try {
            array[campaigns_bulk_operations_list_200_response_inner] result = apiInstance.campaignsBulkOperationsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsBulkOperationsList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];

// List bulk operations
[apiInstance campaignsBulkOperationsListWithCompletionHandler: 
              ^(array[campaigns_bulk_operations_list_200_response_inner] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsBulkOperationsList(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsBulkOperationsListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();

            try {
                // List bulk operations
                array[campaigns_bulk_operations_list_200_response_inner] result = apiInstance.campaignsBulkOperationsList();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsBulkOperationsList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();

try {
    $result = $api_instance->campaignsBulkOperationsList();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsBulkOperationsList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();

eval {
    my $result = $api_instance->campaignsBulkOperationsList();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsBulkOperationsList: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()

try:
    # List bulk operations
    api_response = api_instance.campaigns_bulk_operations_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsBulkOperationsList: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsBulkOperationsList(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        Integer limit = 56; // Integer | 

        try {
            CampaignClassificationsResponse result = apiInstance.campaignsClassificationsGet(campaignId, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsClassificationsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final Integer limit = new Integer(); // Integer | 

try {
    final result = await api_instance.campaignsClassificationsGet(campaignId, limit);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsClassificationsGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        Integer limit = 56; // Integer | 

        try {
            CampaignClassificationsResponse result = apiInstance.campaignsClassificationsGet(campaignId, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsClassificationsGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
Integer *limit = 56; //  (optional) (default to 5)

// Get campaign classification buckets
[apiInstance campaignsClassificationsGetWith:campaignId
    limit:limit
              completionHandler: ^(CampaignClassificationsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var opts = {
  'limit': 56 // {Integer} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsClassificationsGet(campaignId, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsClassificationsGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var limit = 56;  // Integer |  (optional)  (default to 5)

            try {
                // Get campaign classification buckets
                CampaignClassificationsResponse result = apiInstance.campaignsClassificationsGet(campaignId, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsClassificationsGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$limit = 56; // Integer | 

try {
    $result = $api_instance->campaignsClassificationsGet($campaignId, $limit);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsClassificationsGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $limit = 56; # Integer | 

eval {
    my $result = $api_instance->campaignsClassificationsGet(campaignId => $campaignId, limit => $limit);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsClassificationsGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
limit = 56 # Integer |  (optional) (default to 5)

try:
    # Get campaign classification buckets
    api_response = api_instance.campaigns_classifications_get(campaignId, limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsClassificationsGet: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let limit = 56; // Integer

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsClassificationsGet(campaignId, limit, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        CreateCampaignRequest createCampaignRequest = ; // CreateCampaignRequest | 

        try {
            CampaignResponse result = apiInstance.campaignsCreate(createCampaignRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsCreate");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateCampaignRequest createCampaignRequest = new CreateCampaignRequest(); // CreateCampaignRequest | 

try {
    final result = await api_instance.campaignsCreate(createCampaignRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsCreate: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        CreateCampaignRequest createCampaignRequest = ; // CreateCampaignRequest | 

        try {
            CampaignResponse result = apiInstance.campaignsCreate(createCampaignRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsCreate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
CreateCampaignRequest *createCampaignRequest = ; // 

// Create campaign
[apiInstance campaignsCreateWith:createCampaignRequest
              completionHandler: ^(CampaignResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var createCampaignRequest = ; // {CreateCampaignRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsCreate(createCampaignRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsCreateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var createCampaignRequest = new CreateCampaignRequest(); // CreateCampaignRequest | 

            try {
                // Create campaign
                CampaignResponse result = apiInstance.campaignsCreate(createCampaignRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsCreate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$createCampaignRequest = ; // CreateCampaignRequest | 

try {
    $result = $api_instance->campaignsCreate($createCampaignRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsCreate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $createCampaignRequest = WWW::OPenAPIClient::Object::CreateCampaignRequest->new(); # CreateCampaignRequest | 

eval {
    my $result = $api_instance->campaignsCreate(createCampaignRequest => $createCampaignRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsCreate: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
createCampaignRequest =  # CreateCampaignRequest | 

try:
    # Create campaign
    api_response = api_instance.campaigns_create(createCampaignRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsCreate: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let createCampaignRequest = ; // CreateCampaignRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsCreate(createCampaignRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.campaignsDelete(campaignId);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDelete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsDelete(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsDelete: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.campaignsDelete(campaignId);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Delete campaign
[apiInstance campaignsDeleteWith:campaignId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.campaignsDelete(campaignId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Delete campaign
                apiInstance.campaignsDelete(campaignId);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsDelete: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $api_instance->campaignsDelete($campaignId);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    $api_instance->campaignsDelete(campaignId => $campaignId);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsDelete: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Delete campaign
    api_instance.campaigns_delete(campaignId)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsDelete: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsDelete(campaignId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        PatternOffsetRequest patternOffsetRequest = ; // PatternOffsetRequest | 

        try {
            PatternOffsetResponse result = apiInstance.campaignsDomainGenerationPatternOffset(patternOffsetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDomainGenerationPatternOffset");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final PatternOffsetRequest patternOffsetRequest = new PatternOffsetRequest(); // PatternOffsetRequest | 

try {
    final result = await api_instance.campaignsDomainGenerationPatternOffset(patternOffsetRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsDomainGenerationPatternOffset: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        PatternOffsetRequest patternOffsetRequest = ; // PatternOffsetRequest | 

        try {
            PatternOffsetResponse result = apiInstance.campaignsDomainGenerationPatternOffset(patternOffsetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDomainGenerationPatternOffset");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
PatternOffsetRequest *patternOffsetRequest = ; // 

// Get current global pattern offset for domain generation config
[apiInstance campaignsDomainGenerationPatternOffsetWith:patternOffsetRequest
              completionHandler: ^(PatternOffsetResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var patternOffsetRequest = ; // {PatternOffsetRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsDomainGenerationPatternOffset(patternOffsetRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsDomainGenerationPatternOffsetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var patternOffsetRequest = new PatternOffsetRequest(); // PatternOffsetRequest | 

            try {
                // Get current global pattern offset for domain generation config
                PatternOffsetResponse result = apiInstance.campaignsDomainGenerationPatternOffset(patternOffsetRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsDomainGenerationPatternOffset: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$patternOffsetRequest = ; // PatternOffsetRequest | 

try {
    $result = $api_instance->campaignsDomainGenerationPatternOffset($patternOffsetRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsDomainGenerationPatternOffset: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $patternOffsetRequest = WWW::OPenAPIClient::Object::PatternOffsetRequest->new(); # PatternOffsetRequest | 

eval {
    my $result = $api_instance->campaignsDomainGenerationPatternOffset(patternOffsetRequest => $patternOffsetRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsDomainGenerationPatternOffset: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
patternOffsetRequest =  # PatternOffsetRequest | 

try:
    # Get current global pattern offset for domain generation config
    api_response = api_instance.campaigns_domain_generation_pattern_offset(patternOffsetRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsDomainGenerationPatternOffset: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let patternOffsetRequest = ; // PatternOffsetRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsDomainGenerationPatternOffset(patternOffsetRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String domain = domain_example; // String | 

        try {
            DomainScoreBreakdownResponse result = apiInstance.campaignsDomainScoreBreakdown(campaignId, domain);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDomainScoreBreakdown");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final String domain = new String(); // String | 

try {
    final result = await api_instance.campaignsDomainScoreBreakdown(campaignId, domain);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsDomainScoreBreakdown: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String domain = domain_example; // String | 

        try {
            DomainScoreBreakdownResponse result = apiInstance.campaignsDomainScoreBreakdown(campaignId, domain);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDomainScoreBreakdown");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *domain = domain_example; //  (default to null)

// Get detailed score breakdown for a specific domain in a campaign
[apiInstance campaignsDomainScoreBreakdownWith:campaignId
    domain:domain
              completionHandler: ^(DomainScoreBreakdownResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var domain = domain_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsDomainScoreBreakdown(campaignId, domain, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsDomainScoreBreakdownExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var domain = domain_example;  // String |  (default to null)

            try {
                // Get detailed score breakdown for a specific domain in a campaign
                DomainScoreBreakdownResponse result = apiInstance.campaignsDomainScoreBreakdown(campaignId, domain);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsDomainScoreBreakdown: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$domain = domain_example; // String | 

try {
    $result = $api_instance->campaignsDomainScoreBreakdown($campaignId, $domain);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsDomainScoreBreakdown: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $domain = domain_example; # String | 

eval {
    my $result = $api_instance->campaignsDomainScoreBreakdown(campaignId => $campaignId, domain => $domain);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsDomainScoreBreakdown: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
domain = domain_example # String |  (default to null)

try:
    # Get detailed score breakdown for a specific domain in a campaign
    api_response = api_instance.campaigns_domain_score_breakdown(campaignId, domain)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsDomainScoreBreakdown: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let domain = domain_example; // String

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsDomainScoreBreakdown(campaignId, domain, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String dnsStatus = dnsStatus_example; // String | Filter domains whose authoritative DNS status matches (pending|ok|error|timeout)
        String httpStatus = httpStatus_example; // String | Filter domains whose authoritative HTTP status matches (pending|ok|error|timeout)
        String dnsReason = dnsReason_example; // String | Filter domains by DNS reason (exact match). Example values: NXDOMAIN, SERVFAIL, REFUSED, NOANSWER, TIMEOUT, ERROR
        String httpReason = httpReason_example; // String | Filter domains by HTTP reason (exact match). Example values: TIMEOUT, NOT_FOUND, UPSTREAM_5XX, PROXY_ERROR, TLS_ERROR, SSL_EXPIRED, CONNECTION_RESET, ERROR
        Float minScore = 3.4; // Float | Minimum inclusive domain score to include
        Boolean notParked = true; // Boolean | Exclude domains detected as parked
        Boolean hasContact = true; // Boolean | Only include domains with detected contact signals
        String keyword = keyword_example; // String | Require at least one keyword match (any)
        String sort = sort_example; // String | Richness-based sort field (defaults to richness_score when omitted)
        String dir = dir_example; // String | Sort direction (defaults to desc)
        String warnings = warnings_example; // String | Warning filter applied before sorting (has = only domains with penalties; none = only clean domains)
        Integer first = 56; // Integer | Page size for cursor pagination (overrides limit when present)
        String after = after_example; // String | Cursor token to continue listing after

        try {
            CampaignDomainsListResponse result = apiInstance.campaignsDomainsList(campaignId, limit, offset, dnsStatus, httpStatus, dnsReason, httpReason, minScore, notParked, hasContact, keyword, sort, dir, warnings, first, after);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDomainsList");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final Integer limit = new Integer(); // Integer | 
final Integer offset = new Integer(); // Integer | 
final String dnsStatus = new String(); // String | Filter domains whose authoritative DNS status matches (pending|ok|error|timeout)
final String httpStatus = new String(); // String | Filter domains whose authoritative HTTP status matches (pending|ok|error|timeout)
final String dnsReason = new String(); // String | Filter domains by DNS reason (exact match). Example values: NXDOMAIN, SERVFAIL, REFUSED, NOANSWER, TIMEOUT, ERROR
final String httpReason = new String(); // String | Filter domains by HTTP reason (exact match). Example values: TIMEOUT, NOT_FOUND, UPSTREAM_5XX, PROXY_ERROR, TLS_ERROR, SSL_EXPIRED, CONNECTION_RESET, ERROR
final Float minScore = new Float(); // Float | Minimum inclusive domain score to include
final Boolean notParked = new Boolean(); // Boolean | Exclude domains detected as parked
final Boolean hasContact = new Boolean(); // Boolean | Only include domains with detected contact signals
final String keyword = new String(); // String | Require at least one keyword match (any)
final String sort = new String(); // String | Richness-based sort field (defaults to richness_score when omitted)
final String dir = new String(); // String | Sort direction (defaults to desc)
final String warnings = new String(); // String | Warning filter applied before sorting (has = only domains with penalties; none = only clean domains)
final Integer first = new Integer(); // Integer | Page size for cursor pagination (overrides limit when present)
final String after = new String(); // String | Cursor token to continue listing after

try {
    final result = await api_instance.campaignsDomainsList(campaignId, limit, offset, dnsStatus, httpStatus, dnsReason, httpReason, minScore, notParked, hasContact, keyword, sort, dir, warnings, first, after);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsDomainsList: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        String dnsStatus = dnsStatus_example; // String | Filter domains whose authoritative DNS status matches (pending|ok|error|timeout)
        String httpStatus = httpStatus_example; // String | Filter domains whose authoritative HTTP status matches (pending|ok|error|timeout)
        String dnsReason = dnsReason_example; // String | Filter domains by DNS reason (exact match). Example values: NXDOMAIN, SERVFAIL, REFUSED, NOANSWER, TIMEOUT, ERROR
        String httpReason = httpReason_example; // String | Filter domains by HTTP reason (exact match). Example values: TIMEOUT, NOT_FOUND, UPSTREAM_5XX, PROXY_ERROR, TLS_ERROR, SSL_EXPIRED, CONNECTION_RESET, ERROR
        Float minScore = 3.4; // Float | Minimum inclusive domain score to include
        Boolean notParked = true; // Boolean | Exclude domains detected as parked
        Boolean hasContact = true; // Boolean | Only include domains with detected contact signals
        String keyword = keyword_example; // String | Require at least one keyword match (any)
        String sort = sort_example; // String | Richness-based sort field (defaults to richness_score when omitted)
        String dir = dir_example; // String | Sort direction (defaults to desc)
        String warnings = warnings_example; // String | Warning filter applied before sorting (has = only domains with penalties; none = only clean domains)
        Integer first = 56; // Integer | Page size for cursor pagination (overrides limit when present)
        String after = after_example; // String | Cursor token to continue listing after

        try {
            CampaignDomainsListResponse result = apiInstance.campaignsDomainsList(campaignId, limit, offset, dnsStatus, httpStatus, dnsReason, httpReason, minScore, notParked, hasContact, keyword, sort, dir, warnings, first, after);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDomainsList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
Integer *limit = 56; //  (optional) (default to 100)
Integer *offset = 56; //  (optional) (default to 0)
String *dnsStatus = dnsStatus_example; // Filter domains whose authoritative DNS status matches (pending|ok|error|timeout) (optional) (default to null)
String *httpStatus = httpStatus_example; // Filter domains whose authoritative HTTP status matches (pending|ok|error|timeout) (optional) (default to null)
String *dnsReason = dnsReason_example; // Filter domains by DNS reason (exact match). Example values: NXDOMAIN, SERVFAIL, REFUSED, NOANSWER, TIMEOUT, ERROR (optional) (default to null)
String *httpReason = httpReason_example; // Filter domains by HTTP reason (exact match). Example values: TIMEOUT, NOT_FOUND, UPSTREAM_5XX, PROXY_ERROR, TLS_ERROR, SSL_EXPIRED, CONNECTION_RESET, ERROR (optional) (default to null)
Float *minScore = 3.4; // Minimum inclusive domain score to include (optional) (default to null)
Boolean *notParked = true; // Exclude domains detected as parked (optional) (default to null)
Boolean *hasContact = true; // Only include domains with detected contact signals (optional) (default to null)
String *keyword = keyword_example; // Require at least one keyword match (any) (optional) (default to null)
String *sort = sort_example; // Richness-based sort field (defaults to richness_score when omitted) (optional) (default to null)
String *dir = dir_example; // Sort direction (defaults to desc) (optional) (default to null)
String *warnings = warnings_example; // Warning filter applied before sorting (has = only domains with penalties; none = only clean domains) (optional) (default to null)
Integer *first = 56; // Page size for cursor pagination (overrides limit when present) (optional) (default to null)
String *after = after_example; // Cursor token to continue listing after (optional) (default to null)

// List generated domains for a campaign
[apiInstance campaignsDomainsListWith:campaignId
    limit:limit
    offset:offset
    dnsStatus:dnsStatus
    httpStatus:httpStatus
    dnsReason:dnsReason
    httpReason:httpReason
    minScore:minScore
    notParked:notParked
    hasContact:hasContact
    keyword:keyword
    sort:sort
    dir:dir
    warnings:warnings
    first:first
    after:after
              completionHandler: ^(CampaignDomainsListResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var opts = {
  'limit': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'dnsStatus': dnsStatus_example, // {String} Filter domains whose authoritative DNS status matches (pending|ok|error|timeout)
  'httpStatus': httpStatus_example, // {String} Filter domains whose authoritative HTTP status matches (pending|ok|error|timeout)
  'dnsReason': dnsReason_example, // {String} Filter domains by DNS reason (exact match). Example values: NXDOMAIN, SERVFAIL, REFUSED, NOANSWER, TIMEOUT, ERROR
  'httpReason': httpReason_example, // {String} Filter domains by HTTP reason (exact match). Example values: TIMEOUT, NOT_FOUND, UPSTREAM_5XX, PROXY_ERROR, TLS_ERROR, SSL_EXPIRED, CONNECTION_RESET, ERROR
  'minScore': 3.4, // {Float} Minimum inclusive domain score to include
  'notParked': true, // {Boolean} Exclude domains detected as parked
  'hasContact': true, // {Boolean} Only include domains with detected contact signals
  'keyword': keyword_example, // {String} Require at least one keyword match (any)
  'sort': sort_example, // {String} Richness-based sort field (defaults to richness_score when omitted)
  'dir': dir_example, // {String} Sort direction (defaults to desc)
  'warnings': warnings_example, // {String} Warning filter applied before sorting (has = only domains with penalties; none = only clean domains)
  'first': 56, // {Integer} Page size for cursor pagination (overrides limit when present)
  'after': after_example // {String} Cursor token to continue listing after
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsDomainsList(campaignId, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsDomainsListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var limit = 56;  // Integer |  (optional)  (default to 100)
            var offset = 56;  // Integer |  (optional)  (default to 0)
            var dnsStatus = dnsStatus_example;  // String | Filter domains whose authoritative DNS status matches (pending|ok|error|timeout) (optional)  (default to null)
            var httpStatus = httpStatus_example;  // String | Filter domains whose authoritative HTTP status matches (pending|ok|error|timeout) (optional)  (default to null)
            var dnsReason = dnsReason_example;  // String | Filter domains by DNS reason (exact match). Example values: NXDOMAIN, SERVFAIL, REFUSED, NOANSWER, TIMEOUT, ERROR (optional)  (default to null)
            var httpReason = httpReason_example;  // String | Filter domains by HTTP reason (exact match). Example values: TIMEOUT, NOT_FOUND, UPSTREAM_5XX, PROXY_ERROR, TLS_ERROR, SSL_EXPIRED, CONNECTION_RESET, ERROR (optional)  (default to null)
            var minScore = 3.4;  // Float | Minimum inclusive domain score to include (optional)  (default to null)
            var notParked = true;  // Boolean | Exclude domains detected as parked (optional)  (default to null)
            var hasContact = true;  // Boolean | Only include domains with detected contact signals (optional)  (default to null)
            var keyword = keyword_example;  // String | Require at least one keyword match (any) (optional)  (default to null)
            var sort = sort_example;  // String | Richness-based sort field (defaults to richness_score when omitted) (optional)  (default to null)
            var dir = dir_example;  // String | Sort direction (defaults to desc) (optional)  (default to null)
            var warnings = warnings_example;  // String | Warning filter applied before sorting (has = only domains with penalties; none = only clean domains) (optional)  (default to null)
            var first = 56;  // Integer | Page size for cursor pagination (overrides limit when present) (optional)  (default to null)
            var after = after_example;  // String | Cursor token to continue listing after (optional)  (default to null)

            try {
                // List generated domains for a campaign
                CampaignDomainsListResponse result = apiInstance.campaignsDomainsList(campaignId, limit, offset, dnsStatus, httpStatus, dnsReason, httpReason, minScore, notParked, hasContact, keyword, sort, dir, warnings, first, after);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsDomainsList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$limit = 56; // Integer | 
$offset = 56; // Integer | 
$dnsStatus = dnsStatus_example; // String | Filter domains whose authoritative DNS status matches (pending|ok|error|timeout)
$httpStatus = httpStatus_example; // String | Filter domains whose authoritative HTTP status matches (pending|ok|error|timeout)
$dnsReason = dnsReason_example; // String | Filter domains by DNS reason (exact match). Example values: NXDOMAIN, SERVFAIL, REFUSED, NOANSWER, TIMEOUT, ERROR
$httpReason = httpReason_example; // String | Filter domains by HTTP reason (exact match). Example values: TIMEOUT, NOT_FOUND, UPSTREAM_5XX, PROXY_ERROR, TLS_ERROR, SSL_EXPIRED, CONNECTION_RESET, ERROR
$minScore = 3.4; // Float | Minimum inclusive domain score to include
$notParked = true; // Boolean | Exclude domains detected as parked
$hasContact = true; // Boolean | Only include domains with detected contact signals
$keyword = keyword_example; // String | Require at least one keyword match (any)
$sort = sort_example; // String | Richness-based sort field (defaults to richness_score when omitted)
$dir = dir_example; // String | Sort direction (defaults to desc)
$warnings = warnings_example; // String | Warning filter applied before sorting (has = only domains with penalties; none = only clean domains)
$first = 56; // Integer | Page size for cursor pagination (overrides limit when present)
$after = after_example; // String | Cursor token to continue listing after

try {
    $result = $api_instance->campaignsDomainsList($campaignId, $limit, $offset, $dnsStatus, $httpStatus, $dnsReason, $httpReason, $minScore, $notParked, $hasContact, $keyword, $sort, $dir, $warnings, $first, $after);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsDomainsList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $dnsStatus = dnsStatus_example; # String | Filter domains whose authoritative DNS status matches (pending|ok|error|timeout)
my $httpStatus = httpStatus_example; # String | Filter domains whose authoritative HTTP status matches (pending|ok|error|timeout)
my $dnsReason = dnsReason_example; # String | Filter domains by DNS reason (exact match). Example values: NXDOMAIN, SERVFAIL, REFUSED, NOANSWER, TIMEOUT, ERROR
my $httpReason = httpReason_example; # String | Filter domains by HTTP reason (exact match). Example values: TIMEOUT, NOT_FOUND, UPSTREAM_5XX, PROXY_ERROR, TLS_ERROR, SSL_EXPIRED, CONNECTION_RESET, ERROR
my $minScore = 3.4; # Float | Minimum inclusive domain score to include
my $notParked = true; # Boolean | Exclude domains detected as parked
my $hasContact = true; # Boolean | Only include domains with detected contact signals
my $keyword = keyword_example; # String | Require at least one keyword match (any)
my $sort = sort_example; # String | Richness-based sort field (defaults to richness_score when omitted)
my $dir = dir_example; # String | Sort direction (defaults to desc)
my $warnings = warnings_example; # String | Warning filter applied before sorting (has = only domains with penalties; none = only clean domains)
my $first = 56; # Integer | Page size for cursor pagination (overrides limit when present)
my $after = after_example; # String | Cursor token to continue listing after

eval {
    my $result = $api_instance->campaignsDomainsList(campaignId => $campaignId, limit => $limit, offset => $offset, dnsStatus => $dnsStatus, httpStatus => $httpStatus, dnsReason => $dnsReason, httpReason => $httpReason, minScore => $minScore, notParked => $notParked, hasContact => $hasContact, keyword => $keyword, sort => $sort, dir => $dir, warnings => $warnings, first => $first, after => $after);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsDomainsList: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
limit = 56 # Integer |  (optional) (default to 100)
offset = 56 # Integer |  (optional) (default to 0)
dnsStatus = dnsStatus_example # String | Filter domains whose authoritative DNS status matches (pending|ok|error|timeout) (optional) (default to null)
httpStatus = httpStatus_example # String | Filter domains whose authoritative HTTP status matches (pending|ok|error|timeout) (optional) (default to null)
dnsReason = dnsReason_example # String | Filter domains by DNS reason (exact match). Example values: NXDOMAIN, SERVFAIL, REFUSED, NOANSWER, TIMEOUT, ERROR (optional) (default to null)
httpReason = httpReason_example # String | Filter domains by HTTP reason (exact match). Example values: TIMEOUT, NOT_FOUND, UPSTREAM_5XX, PROXY_ERROR, TLS_ERROR, SSL_EXPIRED, CONNECTION_RESET, ERROR (optional) (default to null)
minScore = 3.4 # Float | Minimum inclusive domain score to include (optional) (default to null)
notParked = true # Boolean | Exclude domains detected as parked (optional) (default to null)
hasContact = true # Boolean | Only include domains with detected contact signals (optional) (default to null)
keyword = keyword_example # String | Require at least one keyword match (any) (optional) (default to null)
sort = sort_example # String | Richness-based sort field (defaults to richness_score when omitted) (optional) (default to null)
dir = dir_example # String | Sort direction (defaults to desc) (optional) (default to null)
warnings = warnings_example # String | Warning filter applied before sorting (has = only domains with penalties; none = only clean domains) (optional) (default to null)
first = 56 # Integer | Page size for cursor pagination (overrides limit when present) (optional) (default to null)
after = after_example # String | Cursor token to continue listing after (optional) (default to null)

try:
    # List generated domains for a campaign
    api_response = api_instance.campaigns_domains_list(campaignId, limit=limit, offset=offset, dnsStatus=dnsStatus, httpStatus=httpStatus, dnsReason=dnsReason, httpReason=httpReason, minScore=minScore, notParked=notParked, hasContact=hasContact, keyword=keyword, sort=sort, dir=dir, warnings=warnings, first=first, after=after)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsDomainsList: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let limit = 56; // Integer
    let offset = 56; // Integer
    let dnsStatus = dnsStatus_example; // String
    let httpStatus = httpStatus_example; // String
    let dnsReason = dnsReason_example; // String
    let httpReason = httpReason_example; // String
    let minScore = 3.4; // Float
    let notParked = true; // Boolean
    let hasContact = true; // Boolean
    let keyword = keyword_example; // String
    let sort = sort_example; // String
    let dir = dir_example; // String
    let warnings = warnings_example; // String
    let first = 56; // Integer
    let after = after_example; // String

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsDomainsList(campaignId, limit, offset, dnsStatus, httpStatus, dnsReason, httpReason, minScore, notParked, hasContact, keyword, sort, dir, warnings, first, after, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            CampaignResponse result = apiInstance.campaignsDuplicatePost(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDuplicatePost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsDuplicatePost(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsDuplicatePost: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            CampaignResponse result = apiInstance.campaignsDuplicatePost(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsDuplicatePost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Duplicate campaign
[apiInstance campaignsDuplicatePostWith:campaignId
              completionHandler: ^(CampaignResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsDuplicatePost(campaignId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsDuplicatePostExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Duplicate campaign
                CampaignResponse result = apiInstance.campaignsDuplicatePost(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsDuplicatePost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsDuplicatePost($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsDuplicatePost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsDuplicatePost(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsDuplicatePost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Duplicate campaign
    api_response = api_instance.campaigns_duplicate_post(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsDuplicatePost: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsDuplicatePost(campaignId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            EnrichedCampaignResponse result = apiInstance.campaignsEnrichedGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsEnrichedGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsEnrichedGet(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsEnrichedGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            EnrichedCampaignResponse result = apiInstance.campaignsEnrichedGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsEnrichedGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get enriched campaign details
[apiInstance campaignsEnrichedGetWith:campaignId
              completionHandler: ^(EnrichedCampaignResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsEnrichedGet(campaignId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsEnrichedGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get enriched campaign details
                EnrichedCampaignResponse result = apiInstance.campaignsEnrichedGet(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsEnrichedGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsEnrichedGet($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsEnrichedGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsEnrichedGet(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsEnrichedGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get enriched campaign details
    api_response = api_instance.campaigns_enriched_get(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsEnrichedGet: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsEnrichedGet(campaignId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            CampaignFunnelResponse result = apiInstance.campaignsFunnelGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsFunnelGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsFunnelGet(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsFunnelGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            CampaignFunnelResponse result = apiInstance.campaignsFunnelGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsFunnelGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get campaign funnel snapshot
[apiInstance campaignsFunnelGetWith:campaignId
              completionHandler: ^(CampaignFunnelResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsFunnelGet(campaignId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsFunnelGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get campaign funnel snapshot
                CampaignFunnelResponse result = apiInstance.campaignsFunnelGet(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsFunnelGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsFunnelGet($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsFunnelGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsFunnelGet(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsFunnelGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get campaign funnel snapshot
    api_response = api_instance.campaigns_funnel_get(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsFunnelGet: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsFunnelGet(campaignId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            CampaignResponse result = apiInstance.campaignsGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsGet(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            CampaignResponse result = apiInstance.campaignsGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get campaign
[apiInstance campaignsGetWith:campaignId
              completionHandler: ^(CampaignResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsGet(campaignId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get campaign
                CampaignResponse result = apiInstance.campaignsGet(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsGet($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsGet(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get campaign
    api_response = api_instance.campaigns_get(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsGet: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsGet(campaignId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();

        try {
            array[CampaignResponse] result = apiInstance.campaignsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsList");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.campaignsList();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsList: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();

        try {
            array[CampaignResponse] result = apiInstance.campaignsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];

// List campaigns
[apiInstance campaignsListWithCompletionHandler: 
              ^(array[CampaignResponse] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsList(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();

            try {
                // List campaigns
                array[CampaignResponse] result = apiInstance.campaignsList();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();

try {
    $result = $api_instance->campaignsList();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();

eval {
    my $result = $api_instance->campaignsList();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsList: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()

try:
    # List campaigns
    api_response = api_instance.campaigns_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsList: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsList(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            CampaignMetricsResponse result = apiInstance.campaignsMetricsGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsMetricsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsMetricsGet(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsMetricsGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            CampaignMetricsResponse result = apiInstance.campaignsMetricsGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsMetricsGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get campaign KPI & warning metrics
[apiInstance campaignsMetricsGetWith:campaignId
              completionHandler: ^(CampaignMetricsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsMetricsGet(campaignId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsMetricsGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get campaign KPI & warning metrics
                CampaignMetricsResponse result = apiInstance.campaignsMetricsGet(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsMetricsGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsMetricsGet($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsMetricsGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsMetricsGet(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsMetricsGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get campaign KPI & warning metrics
    api_response = api_instance.campaigns_metrics_get(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsMetricsGet: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsMetricsGet(campaignId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        CampaignsModeUpdateRequest campaignsModeUpdateRequest = ; // CampaignsModeUpdateRequest | 

        try {
            CampaignModeUpdateResponse result = apiInstance.campaignsModeUpdate(campaignId, campaignsModeUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsModeUpdate");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final CampaignsModeUpdateRequest campaignsModeUpdateRequest = new CampaignsModeUpdateRequest(); // CampaignsModeUpdateRequest | 

try {
    final result = await api_instance.campaignsModeUpdate(campaignId, campaignsModeUpdateRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsModeUpdate: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        CampaignsModeUpdateRequest campaignsModeUpdateRequest = ; // CampaignsModeUpdateRequest | 

        try {
            CampaignModeUpdateResponse result = apiInstance.campaignsModeUpdate(campaignId, campaignsModeUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsModeUpdate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
CampaignsModeUpdateRequest *campaignsModeUpdateRequest = ; // 

// Update campaign execution mode
[apiInstance campaignsModeUpdateWith:campaignId
    campaignsModeUpdateRequest:campaignsModeUpdateRequest
              completionHandler: ^(CampaignModeUpdateResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var campaignsModeUpdateRequest = ; // {CampaignsModeUpdateRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsModeUpdate(campaignId, campaignsModeUpdateRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsModeUpdateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var campaignsModeUpdateRequest = new CampaignsModeUpdateRequest(); // CampaignsModeUpdateRequest | 

            try {
                // Update campaign execution mode
                CampaignModeUpdateResponse result = apiInstance.campaignsModeUpdate(campaignId, campaignsModeUpdateRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsModeUpdate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$campaignsModeUpdateRequest = ; // CampaignsModeUpdateRequest | 

try {
    $result = $api_instance->campaignsModeUpdate($campaignId, $campaignsModeUpdateRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsModeUpdate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $campaignsModeUpdateRequest = WWW::OPenAPIClient::Object::CampaignsModeUpdateRequest->new(); # CampaignsModeUpdateRequest | 

eval {
    my $result = $api_instance->campaignsModeUpdate(campaignId => $campaignId, campaignsModeUpdateRequest => $campaignsModeUpdateRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsModeUpdate: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
campaignsModeUpdateRequest =  # CampaignsModeUpdateRequest | 

try:
    # Update campaign execution mode
    api_response = api_instance.campaigns_mode_update(campaignId, campaignsModeUpdateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsModeUpdate: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let campaignsModeUpdateRequest = ; // CampaignsModeUpdateRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsModeUpdate(campaignId, campaignsModeUpdateRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            CampaignMomentumResponse result = apiInstance.campaignsMomentumGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsMomentumGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsMomentumGet(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsMomentumGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            CampaignMomentumResponse result = apiInstance.campaignsMomentumGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsMomentumGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get campaign momentum & movers
[apiInstance campaignsMomentumGetWith:campaignId
              completionHandler: ^(CampaignMomentumResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsMomentumGet(campaignId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsMomentumGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get campaign momentum & movers
                CampaignMomentumResponse result = apiInstance.campaignsMomentumGet(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsMomentumGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsMomentumGet($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsMomentumGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsMomentumGet(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsMomentumGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get campaign momentum & movers
    api_response = api_instance.campaigns_momentum_get(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsMomentumGet: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsMomentumGet(campaignId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_phase_configs_list_200_response result = apiInstance.campaignsPhaseConfigsList(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseConfigsList");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsPhaseConfigsList(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseConfigsList: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            campaigns_phase_configs_list_200_response result = apiInstance.campaignsPhaseConfigsList(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseConfigsList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// List stored phase configurations for a campaign
[apiInstance campaignsPhaseConfigsListWith:campaignId
              completionHandler: ^(campaigns_phase_configs_list_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseConfigsList(campaignId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseConfigsListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // List stored phase configurations for a campaign
                campaigns_phase_configs_list_200_response result = apiInstance.campaignsPhaseConfigsList(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseConfigsList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsPhaseConfigsList($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseConfigsList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsPhaseConfigsList(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseConfigsList: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # List stored phase configurations for a campaign
    api_response = api_instance.campaigns_phase_configs_list(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseConfigsList: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseConfigsList(campaignId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        CampaignPhaseEnum phase = ; // CampaignPhaseEnum | 
        PhaseConfigurationRequest phaseConfigurationRequest = ; // PhaseConfigurationRequest | 

        try {
            PhaseStatusResponse result = apiInstance.campaignsPhaseConfigure(campaignId, phase, phaseConfigurationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseConfigure");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final CampaignPhaseEnum phase = new CampaignPhaseEnum(); // CampaignPhaseEnum | 
final PhaseConfigurationRequest phaseConfigurationRequest = new PhaseConfigurationRequest(); // PhaseConfigurationRequest | 

try {
    final result = await api_instance.campaignsPhaseConfigure(campaignId, phase, phaseConfigurationRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseConfigure: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        CampaignPhaseEnum phase = ; // CampaignPhaseEnum | 
        PhaseConfigurationRequest phaseConfigurationRequest = ; // PhaseConfigurationRequest | 

        try {
            PhaseStatusResponse result = apiInstance.campaignsPhaseConfigure(campaignId, phase, phaseConfigurationRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseConfigure");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
CampaignPhaseEnum *phase = ; //  (default to null)
PhaseConfigurationRequest *phaseConfigurationRequest = ; // 

// Configure campaign phase
[apiInstance campaignsPhaseConfigureWith:campaignId
    phase:phase
    phaseConfigurationRequest:phaseConfigurationRequest
              completionHandler: ^(PhaseStatusResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phase = ; // {CampaignPhaseEnum} 
var phaseConfigurationRequest = ; // {PhaseConfigurationRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseConfigure(campaignId, phase, phaseConfigurationRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseConfigureExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phase = new CampaignPhaseEnum(); // CampaignPhaseEnum |  (default to null)
            var phaseConfigurationRequest = new PhaseConfigurationRequest(); // PhaseConfigurationRequest | 

            try {
                // Configure campaign phase
                PhaseStatusResponse result = apiInstance.campaignsPhaseConfigure(campaignId, phase, phaseConfigurationRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseConfigure: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phase = ; // CampaignPhaseEnum | 
$phaseConfigurationRequest = ; // PhaseConfigurationRequest | 

try {
    $result = $api_instance->campaignsPhaseConfigure($campaignId, $phase, $phaseConfigurationRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseConfigure: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phase = ; # CampaignPhaseEnum | 
my $phaseConfigurationRequest = WWW::OPenAPIClient::Object::PhaseConfigurationRequest->new(); # PhaseConfigurationRequest | 

eval {
    my $result = $api_instance->campaignsPhaseConfigure(campaignId => $campaignId, phase => $phase, phaseConfigurationRequest => $phaseConfigurationRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseConfigure: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phase =  # CampaignPhaseEnum |  (default to null)
phaseConfigurationRequest =  # PhaseConfigurationRequest | 

try:
    # Configure campaign phase
    api_response = api_instance.campaigns_phase_configure(campaignId, phase, phaseConfigurationRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseConfigure: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phase = ; // CampaignPhaseEnum
    let phaseConfigurationRequest = ; // PhaseConfigurationRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseConfigure(campaignId, phase, phaseConfigurationRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phaseType = phaseType_example; // String | 

        try {
            apiInstance.campaignsPhaseExecutionDelete(campaignId, phaseType);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionDelete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final String phaseType = new String(); // String | 

try {
    final result = await api_instance.campaignsPhaseExecutionDelete(campaignId, phaseType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseExecutionDelete: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phaseType = phaseType_example; // String | 

        try {
            apiInstance.campaignsPhaseExecutionDelete(campaignId, phaseType);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *phaseType = phaseType_example; //  (default to null)

// Delete phase execution by phase type
[apiInstance campaignsPhaseExecutionDeleteWith:campaignId
    phaseType:phaseType
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phaseType = phaseType_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.campaignsPhaseExecutionDelete(campaignId, phaseType, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseExecutionDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phaseType = phaseType_example;  // String |  (default to null)

            try {
                // Delete phase execution by phase type
                apiInstance.campaignsPhaseExecutionDelete(campaignId, phaseType);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseExecutionDelete: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phaseType = phaseType_example; // String | 

try {
    $api_instance->campaignsPhaseExecutionDelete($campaignId, $phaseType);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseExecutionDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phaseType = phaseType_example; # String | 

eval {
    $api_instance->campaignsPhaseExecutionDelete(campaignId => $campaignId, phaseType => $phaseType);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseExecutionDelete: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phaseType = phaseType_example # String |  (default to null)

try:
    # Delete phase execution by phase type
    api_instance.campaigns_phase_execution_delete(campaignId, phaseType)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseExecutionDelete: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phaseType = phaseType_example; // String

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseExecutionDelete(campaignId, phaseType, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phaseType = phaseType_example; // String | 

        try {
            PhaseExecution result = apiInstance.campaignsPhaseExecutionGet(campaignId, phaseType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final String phaseType = new String(); // String | 

try {
    final result = await api_instance.campaignsPhaseExecutionGet(campaignId, phaseType);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseExecutionGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phaseType = phaseType_example; // String | 

        try {
            PhaseExecution result = apiInstance.campaignsPhaseExecutionGet(campaignId, phaseType);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *phaseType = phaseType_example; //  (default to null)

// Get phase execution by phase type
[apiInstance campaignsPhaseExecutionGetWith:campaignId
    phaseType:phaseType
              completionHandler: ^(PhaseExecution output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phaseType = phaseType_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseExecutionGet(campaignId, phaseType, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseExecutionGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phaseType = phaseType_example;  // String |  (default to null)

            try {
                // Get phase execution by phase type
                PhaseExecution result = apiInstance.campaignsPhaseExecutionGet(campaignId, phaseType);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseExecutionGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phaseType = phaseType_example; // String | 

try {
    $result = $api_instance->campaignsPhaseExecutionGet($campaignId, $phaseType);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseExecutionGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phaseType = phaseType_example; # String | 

eval {
    my $result = $api_instance->campaignsPhaseExecutionGet(campaignId => $campaignId, phaseType => $phaseType);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseExecutionGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phaseType = phaseType_example # String |  (default to null)

try:
    # Get phase execution by phase type
    api_response = api_instance.campaigns_phase_execution_get(campaignId, phaseType)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseExecutionGet: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phaseType = phaseType_example; // String

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseExecutionGet(campaignId, phaseType, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phaseType = phaseType_example; // String | 
        PhaseExecutionUpdate phaseExecutionUpdate = ; // PhaseExecutionUpdate | 

        try {
            PhaseExecution result = apiInstance.campaignsPhaseExecutionPut(campaignId, phaseType, phaseExecutionUpdate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionPut");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final String phaseType = new String(); // String | 
final PhaseExecutionUpdate phaseExecutionUpdate = new PhaseExecutionUpdate(); // PhaseExecutionUpdate | 

try {
    final result = await api_instance.campaignsPhaseExecutionPut(campaignId, phaseType, phaseExecutionUpdate);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseExecutionPut: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        String phaseType = phaseType_example; // String | 
        PhaseExecutionUpdate phaseExecutionUpdate = ; // PhaseExecutionUpdate | 

        try {
            PhaseExecution result = apiInstance.campaignsPhaseExecutionPut(campaignId, phaseType, phaseExecutionUpdate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionPut");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
String *phaseType = phaseType_example; //  (default to null)
PhaseExecutionUpdate *phaseExecutionUpdate = ; // 

// Update phase execution by phase type
[apiInstance campaignsPhaseExecutionPutWith:campaignId
    phaseType:phaseType
    phaseExecutionUpdate:phaseExecutionUpdate
              completionHandler: ^(PhaseExecution output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phaseType = phaseType_example; // {String} 
var phaseExecutionUpdate = ; // {PhaseExecutionUpdate} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseExecutionPut(campaignId, phaseType, phaseExecutionUpdate, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseExecutionPutExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phaseType = phaseType_example;  // String |  (default to null)
            var phaseExecutionUpdate = new PhaseExecutionUpdate(); // PhaseExecutionUpdate | 

            try {
                // Update phase execution by phase type
                PhaseExecution result = apiInstance.campaignsPhaseExecutionPut(campaignId, phaseType, phaseExecutionUpdate);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseExecutionPut: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phaseType = phaseType_example; // String | 
$phaseExecutionUpdate = ; // PhaseExecutionUpdate | 

try {
    $result = $api_instance->campaignsPhaseExecutionPut($campaignId, $phaseType, $phaseExecutionUpdate);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseExecutionPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phaseType = phaseType_example; # String | 
my $phaseExecutionUpdate = WWW::OPenAPIClient::Object::PhaseExecutionUpdate->new(); # PhaseExecutionUpdate | 

eval {
    my $result = $api_instance->campaignsPhaseExecutionPut(campaignId => $campaignId, phaseType => $phaseType, phaseExecutionUpdate => $phaseExecutionUpdate);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseExecutionPut: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phaseType = phaseType_example # String |  (default to null)
phaseExecutionUpdate =  # PhaseExecutionUpdate | 

try:
    # Update phase execution by phase type
    api_response = api_instance.campaigns_phase_execution_put(campaignId, phaseType, phaseExecutionUpdate)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseExecutionPut: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phaseType = phaseType_example; // String
    let phaseExecutionUpdate = ; // PhaseExecutionUpdate

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseExecutionPut(campaignId, phaseType, phaseExecutionUpdate, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            CampaignStateWithExecutions result = apiInstance.campaignsPhaseExecutionsList(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionsList");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsPhaseExecutionsList(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseExecutionsList: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            CampaignStateWithExecutions result = apiInstance.campaignsPhaseExecutionsList(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseExecutionsList");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// List phase executions for a campaign
[apiInstance campaignsPhaseExecutionsListWith:campaignId
              completionHandler: ^(CampaignStateWithExecutions output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseExecutionsList(campaignId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseExecutionsListExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // List phase executions for a campaign
                CampaignStateWithExecutions result = apiInstance.campaignsPhaseExecutionsList(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseExecutionsList: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsPhaseExecutionsList($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseExecutionsList: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsPhaseExecutionsList(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseExecutionsList: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # List phase executions for a campaign
    api_response = api_instance.campaigns_phase_executions_list(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseExecutionsList: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseExecutionsList(campaignId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        CampaignPhaseEnum phase = ; // CampaignPhaseEnum | 

        try {
            PhaseStatusResponse result = apiInstance.campaignsPhaseStart(campaignId, phase);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseStart");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final CampaignPhaseEnum phase = new CampaignPhaseEnum(); // CampaignPhaseEnum | 

try {
    final result = await api_instance.campaignsPhaseStart(campaignId, phase);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseStart: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        CampaignPhaseEnum phase = ; // CampaignPhaseEnum | 

        try {
            PhaseStatusResponse result = apiInstance.campaignsPhaseStart(campaignId, phase);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseStart");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
CampaignPhaseEnum *phase = ; //  (default to null)

// Start campaign phase
[apiInstance campaignsPhaseStartWith:campaignId
    phase:phase
              completionHandler: ^(PhaseStatusResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phase = ; // {CampaignPhaseEnum} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseStart(campaignId, phase, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseStartExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phase = new CampaignPhaseEnum(); // CampaignPhaseEnum |  (default to null)

            try {
                // Start campaign phase
                PhaseStatusResponse result = apiInstance.campaignsPhaseStart(campaignId, phase);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseStart: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phase = ; // CampaignPhaseEnum | 

try {
    $result = $api_instance->campaignsPhaseStart($campaignId, $phase);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseStart: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phase = ; # CampaignPhaseEnum | 

eval {
    my $result = $api_instance->campaignsPhaseStart(campaignId => $campaignId, phase => $phase);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseStart: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phase =  # CampaignPhaseEnum |  (default to null)

try:
    # Start campaign phase
    api_response = api_instance.campaigns_phase_start(campaignId, phase)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseStart: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phase = ; // CampaignPhaseEnum

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseStart(campaignId, phase, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        CampaignPhaseEnum phase = ; // CampaignPhaseEnum | 

        try {
            PhaseStatusResponse result = apiInstance.campaignsPhaseStatus(campaignId, phase);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseStatus");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final CampaignPhaseEnum phase = new CampaignPhaseEnum(); // CampaignPhaseEnum | 

try {
    final result = await api_instance.campaignsPhaseStatus(campaignId, phase);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseStatus: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        CampaignPhaseEnum phase = ; // CampaignPhaseEnum | 

        try {
            PhaseStatusResponse result = apiInstance.campaignsPhaseStatus(campaignId, phase);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseStatus");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
CampaignPhaseEnum *phase = ; //  (default to null)

// Get phase status
[apiInstance campaignsPhaseStatusWith:campaignId
    phase:phase
              completionHandler: ^(PhaseStatusResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phase = ; // {CampaignPhaseEnum} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseStatus(campaignId, phase, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseStatusExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phase = new CampaignPhaseEnum(); // CampaignPhaseEnum |  (default to null)

            try {
                // Get phase status
                PhaseStatusResponse result = apiInstance.campaignsPhaseStatus(campaignId, phase);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseStatus: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phase = ; // CampaignPhaseEnum | 

try {
    $result = $api_instance->campaignsPhaseStatus($campaignId, $phase);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseStatus: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phase = ; # CampaignPhaseEnum | 

eval {
    my $result = $api_instance->campaignsPhaseStatus(campaignId => $campaignId, phase => $phase);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseStatus: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phase =  # CampaignPhaseEnum |  (default to null)

try:
    # Get phase status
    api_response = api_instance.campaigns_phase_status(campaignId, phase)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseStatus: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phase = ; // CampaignPhaseEnum

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseStatus(campaignId, phase, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        CampaignPhaseEnum phase = ; // CampaignPhaseEnum | 

        try {
            PhaseStatusResponse result = apiInstance.campaignsPhaseStop(campaignId, phase);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseStop");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final CampaignPhaseEnum phase = new CampaignPhaseEnum(); // CampaignPhaseEnum | 

try {
    final result = await api_instance.campaignsPhaseStop(campaignId, phase);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsPhaseStop: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        CampaignPhaseEnum phase = ; // CampaignPhaseEnum | 

        try {
            PhaseStatusResponse result = apiInstance.campaignsPhaseStop(campaignId, phase);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsPhaseStop");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
CampaignPhaseEnum *phase = ; //  (default to null)

// Stop campaign phase
[apiInstance campaignsPhaseStopWith:campaignId
    phase:phase
              completionHandler: ^(PhaseStatusResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var phase = ; // {CampaignPhaseEnum} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsPhaseStop(campaignId, phase, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsPhaseStopExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var phase = new CampaignPhaseEnum(); // CampaignPhaseEnum |  (default to null)

            try {
                // Stop campaign phase
                PhaseStatusResponse result = apiInstance.campaignsPhaseStop(campaignId, phase);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsPhaseStop: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$phase = ; // CampaignPhaseEnum | 

try {
    $result = $api_instance->campaignsPhaseStop($campaignId, $phase);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsPhaseStop: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $phase = ; # CampaignPhaseEnum | 

eval {
    my $result = $api_instance->campaignsPhaseStop(campaignId => $campaignId, phase => $phase);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsPhaseStop: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
phase =  # CampaignPhaseEnum |  (default to null)

try:
    # Stop campaign phase
    api_response = api_instance.campaigns_phase_stop(campaignId, phase)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsPhaseStop: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let phase = ; // CampaignPhaseEnum

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsPhaseStop(campaignId, phase, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            CampaignProgressResponse result = apiInstance.campaignsProgress(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsProgress");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsProgress(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsProgress: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            CampaignProgressResponse result = apiInstance.campaignsProgress(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsProgress");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get campaign progress
[apiInstance campaignsProgressWith:campaignId
              completionHandler: ^(CampaignProgressResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsProgress(campaignId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsProgressExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get campaign progress
                CampaignProgressResponse result = apiInstance.campaignsProgress(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsProgress: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsProgress($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsProgress: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsProgress(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsProgress: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get campaign progress
    api_response = api_instance.campaigns_progress(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsProgress: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsProgress(campaignId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            CampaignRecommendationsResponse result = apiInstance.campaignsRecommendationsGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsRecommendationsGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsRecommendationsGet(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsRecommendationsGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            CampaignRecommendationsResponse result = apiInstance.campaignsRecommendationsGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsRecommendationsGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get campaign recommendations
[apiInstance campaignsRecommendationsGetWith:campaignId
              completionHandler: ^(CampaignRecommendationsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsRecommendationsGet(campaignId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsRecommendationsGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get campaign recommendations
                CampaignRecommendationsResponse result = apiInstance.campaignsRecommendationsGet(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsRecommendationsGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsRecommendationsGet($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsRecommendationsGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsRecommendationsGet(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsRecommendationsGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get campaign recommendations
    api_response = api_instance.campaigns_recommendations_get(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsRecommendationsGet: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsRecommendationsGet(campaignId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.campaignsStateDelete(campaignId);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStateDelete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsStateDelete(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsStateDelete: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.campaignsStateDelete(campaignId);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStateDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Delete campaign state
[apiInstance campaignsStateDeleteWith:campaignId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.campaignsStateDelete(campaignId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsStateDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Delete campaign state
                apiInstance.campaignsStateDelete(campaignId);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsStateDelete: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $api_instance->campaignsStateDelete($campaignId);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsStateDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    $api_instance->campaignsStateDelete(campaignId => $campaignId);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsStateDelete: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Delete campaign state
    api_instance.campaigns_state_delete(campaignId)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsStateDelete: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsStateDelete(campaignId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            CampaignState result = apiInstance.campaignsStateGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStateGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsStateGet(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsStateGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            CampaignState result = apiInstance.campaignsStateGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStateGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get campaign state
[apiInstance campaignsStateGetWith:campaignId
              completionHandler: ^(CampaignState output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsStateGet(campaignId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsStateGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get campaign state
                CampaignState result = apiInstance.campaignsStateGet(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsStateGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsStateGet($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsStateGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsStateGet(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsStateGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get campaign state
    api_response = api_instance.campaigns_state_get(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsStateGet: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsStateGet(campaignId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        CampaignStateUpdate campaignStateUpdate = ; // CampaignStateUpdate | 

        try {
            CampaignState result = apiInstance.campaignsStatePut(campaignId, campaignStateUpdate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStatePut");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final CampaignStateUpdate campaignStateUpdate = new CampaignStateUpdate(); // CampaignStateUpdate | 

try {
    final result = await api_instance.campaignsStatePut(campaignId, campaignStateUpdate);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsStatePut: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        CampaignStateUpdate campaignStateUpdate = ; // CampaignStateUpdate | 

        try {
            CampaignState result = apiInstance.campaignsStatePut(campaignId, campaignStateUpdate);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStatePut");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
CampaignStateUpdate *campaignStateUpdate = ; // 

// Update campaign state
[apiInstance campaignsStatePutWith:campaignId
    campaignStateUpdate:campaignStateUpdate
              completionHandler: ^(CampaignState output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var campaignStateUpdate = ; // {CampaignStateUpdate} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsStatePut(campaignId, campaignStateUpdate, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsStatePutExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var campaignStateUpdate = new CampaignStateUpdate(); // CampaignStateUpdate | 

            try {
                // Update campaign state
                CampaignState result = apiInstance.campaignsStatePut(campaignId, campaignStateUpdate);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsStatePut: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$campaignStateUpdate = ; // CampaignStateUpdate | 

try {
    $result = $api_instance->campaignsStatePut($campaignId, $campaignStateUpdate);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsStatePut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $campaignStateUpdate = WWW::OPenAPIClient::Object::CampaignStateUpdate->new(); # CampaignStateUpdate | 

eval {
    my $result = $api_instance->campaignsStatePut(campaignId => $campaignId, campaignStateUpdate => $campaignStateUpdate);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsStatePut: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
campaignStateUpdate =  # CampaignStateUpdate | 

try:
    # Update campaign state
    api_response = api_instance.campaigns_state_put(campaignId, campaignStateUpdate)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsStatePut: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let campaignStateUpdate = ; // CampaignStateUpdate

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsStatePut(campaignId, campaignStateUpdate, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            CampaignPhasesStatusResponse result = apiInstance.campaignsStatusGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStatusGet");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 

try {
    final result = await api_instance.campaignsStatusGet(campaignId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsStatusGet: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            CampaignPhasesStatusResponse result = apiInstance.campaignsStatusGet(campaignId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsStatusGet");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get consolidated campaign phase statuses
[apiInstance campaignsStatusGetWith:campaignId
              completionHandler: ^(CampaignPhasesStatusResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsStatusGet(campaignId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsStatusGetExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get consolidated campaign phase statuses
                CampaignPhasesStatusResponse result = apiInstance.campaignsStatusGet(campaignId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsStatusGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->campaignsStatusGet($campaignId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsStatusGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->campaignsStatusGet(campaignId => $campaignId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsStatusGet: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get consolidated campaign phase statuses
    api_response = api_instance.campaigns_status_get(campaignId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsStatusGet: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsStatusGet(campaignId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdateCampaignRequest updateCampaignRequest = ; // UpdateCampaignRequest | 

        try {
            CampaignResponse result = apiInstance.campaignsUpdate(campaignId, updateCampaignRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsUpdate");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID campaignId = new UUID(); // UUID | 
final UpdateCampaignRequest updateCampaignRequest = new UpdateCampaignRequest(); // UpdateCampaignRequest | 

try {
    final result = await api_instance.campaignsUpdate(campaignId, updateCampaignRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->campaignsUpdate: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UpdateCampaignRequest updateCampaignRequest = ; // UpdateCampaignRequest | 

        try {
            CampaignResponse result = apiInstance.campaignsUpdate(campaignId, updateCampaignRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#campaignsUpdate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
UpdateCampaignRequest *updateCampaignRequest = ; // 

// Update campaign
[apiInstance campaignsUpdateWith:campaignId
    updateCampaignRequest:updateCampaignRequest
              completionHandler: ^(CampaignResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var updateCampaignRequest = ; // {UpdateCampaignRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.campaignsUpdate(campaignId, updateCampaignRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class campaignsUpdateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var updateCampaignRequest = new UpdateCampaignRequest(); // UpdateCampaignRequest | 

            try {
                // Update campaign
                CampaignResponse result = apiInstance.campaignsUpdate(campaignId, updateCampaignRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.campaignsUpdate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$updateCampaignRequest = ; // UpdateCampaignRequest | 

try {
    $result = $api_instance->campaignsUpdate($campaignId, $updateCampaignRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->campaignsUpdate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $updateCampaignRequest = WWW::OPenAPIClient::Object::UpdateCampaignRequest->new(); # UpdateCampaignRequest | 

eval {
    my $result = $api_instance->campaignsUpdate(campaignId => $campaignId, updateCampaignRequest => $updateCampaignRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->campaignsUpdate: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
updateCampaignRequest =  # UpdateCampaignRequest | 

try:
    # Update campaign
    api_response = api_instance.campaigns_update(campaignId, updateCampaignRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->campaignsUpdate: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let campaignId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let updateCampaignRequest = ; // UpdateCampaignRequest

    let mut context = CampaignsApi::Context::default();
    let result = client.campaignsUpdate(campaignId, updateCampaignRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            cancelBulkOperation_200_response result = apiInstance.cancelBulkOperation(operationId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#cancelBulkOperation");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID operationId = new UUID(); // UUID | 

try {
    final result = await api_instance.cancelBulkOperation(operationId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->cancelBulkOperation: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            cancelBulkOperation_200_response result = apiInstance.cancelBulkOperation(operationId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#cancelBulkOperation");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Cancel a bulk operation
[apiInstance cancelBulkOperationWith:operationId
              completionHandler: ^(cancelBulkOperation_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.cancelBulkOperation(operationId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class cancelBulkOperationExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Cancel a bulk operation
                cancelBulkOperation_200_response result = apiInstance.cancelBulkOperation(operationId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.cancelBulkOperation: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->cancelBulkOperation($operationId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->cancelBulkOperation: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->cancelBulkOperation(operationId => $operationId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->cancelBulkOperation: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Cancel a bulk operation
    api_response = api_instance.cancel_bulk_operation(operationId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->cancelBulkOperation: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.cancelBulkOperation(operationId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Bulk operation ID

        try {
            getBulkOperationStatus_200_response result = apiInstance.getBulkOperationStatus(operationId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#getBulkOperationStatus");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID operationId = new UUID(); // UUID | Bulk operation ID

try {
    final result = await api_instance.getBulkOperationStatus(operationId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getBulkOperationStatus: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Bulk operation ID

        try {
            getBulkOperationStatus_200_response result = apiInstance.getBulkOperationStatus(operationId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#getBulkOperationStatus");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Bulk operation ID (default to null)

// Get bulk operation status
[apiInstance getBulkOperationStatusWith:operationId
              completionHandler: ^(getBulkOperationStatus_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} Bulk operation ID

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getBulkOperationStatus(operationId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getBulkOperationStatusExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID | Bulk operation ID (default to null)

            try {
                // Get bulk operation status
                getBulkOperationStatus_200_response result = apiInstance.getBulkOperationStatus(operationId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.getBulkOperationStatus: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Bulk operation ID

try {
    $result = $api_instance->getBulkOperationStatus($operationId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->getBulkOperationStatus: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Bulk operation ID

eval {
    my $result = $api_instance->getBulkOperationStatus(operationId => $operationId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->getBulkOperationStatus: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Bulk operation ID (default to null)

try:
    # Get bulk operation status
    api_response = api_instance.get_bulk_operation_status(operationId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->getBulkOperationStatus: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let operationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.getBulkOperationStatus(operationId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CampaignsApi;

import java.io.File;
import java.util.*;

public class CampaignsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        CampaignsApi apiInstance = new CampaignsApi();
        UUID allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            getBulkResourceStatus_200_response result = apiInstance.getBulkResourceStatus(allocationId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#getBulkResourceStatus");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID allocationId = new UUID(); // UUID | 

try {
    final result = await api_instance.getBulkResourceStatus(allocationId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getBulkResourceStatus: $e\n');
}

import org.openapitools.client.api.CampaignsApi;

public class CampaignsApiExample {
    public static void main(String[] args) {
        CampaignsApi apiInstance = new CampaignsApi();
        UUID allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            getBulkResourceStatus_200_response result = apiInstance.getBulkResourceStatus(allocationId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CampaignsApi#getBulkResourceStatus");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
CampaignsApi *apiInstance = [[CampaignsApi alloc] init];
UUID *allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Get status of bulk resource allocation
[apiInstance getBulkResourceStatusWith:allocationId
              completionHandler: ^(getBulkResourceStatus_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.CampaignsApi()
var allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getBulkResourceStatus(allocationId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getBulkResourceStatusExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new CampaignsApi();
            var allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Get status of bulk resource allocation
                getBulkResourceStatus_200_response result = apiInstance.getBulkResourceStatus(allocationId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CampaignsApi.getBulkResourceStatus: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CampaignsApi();
$allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->getBulkResourceStatus($allocationId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CampaignsApi->getBulkResourceStatus: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CampaignsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CampaignsApi->new();
my $allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->getBulkResourceStatus(allocationId => $allocationId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CampaignsApi->getBulkResourceStatus: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.CampaignsApi()
allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Get status of bulk resource allocation
    api_response = api_instance.get_bulk_resource_status(allocationId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CampaignsApi->getBulkResourceStatus: %s\n" % e)

extern crate CampaignsApi;

pub fn main() {
    let allocationId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = CampaignsApi::Context::default();
    let result = client.getBulkResourceStatus(allocationId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DatabaseApi;

import java.io.File;
import java.util.*;

public class DatabaseApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DatabaseApi apiInstance = new DatabaseApi();
        BulkDatabaseQueryRequest bulkDatabaseQueryRequest = ; // BulkDatabaseQueryRequest | 
        String xRequestedWith = xRequestedWith_example; // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

        try {
            BulkDatabaseQueryResponse result = apiInstance.dbBulkQuery(bulkDatabaseQueryRequest, xRequestedWith);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseApi#dbBulkQuery");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkDatabaseQueryRequest bulkDatabaseQueryRequest = new BulkDatabaseQueryRequest(); // BulkDatabaseQueryRequest | 
final String xRequestedWith = new String(); // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

try {
    final result = await api_instance.dbBulkQuery(bulkDatabaseQueryRequest, xRequestedWith);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->dbBulkQuery: $e\n');
}

import org.openapitools.client.api.DatabaseApi;

public class DatabaseApiExample {
    public static void main(String[] args) {
        DatabaseApi apiInstance = new DatabaseApi();
        BulkDatabaseQueryRequest bulkDatabaseQueryRequest = ; // BulkDatabaseQueryRequest | 
        String xRequestedWith = xRequestedWith_example; // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

        try {
            BulkDatabaseQueryResponse result = apiInstance.dbBulkQuery(bulkDatabaseQueryRequest, xRequestedWith);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseApi#dbBulkQuery");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
DatabaseApi *apiInstance = [[DatabaseApi alloc] init];
BulkDatabaseQueryRequest *bulkDatabaseQueryRequest = ; // 
String *xRequestedWith = xRequestedWith_example; // CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests. (optional) (default to null)

// Execute bulk database queries
[apiInstance dbBulkQueryWith:bulkDatabaseQueryRequest
    xRequestedWith:xRequestedWith
              completionHandler: ^(BulkDatabaseQueryResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.DatabaseApi()
var bulkDatabaseQueryRequest = ; // {BulkDatabaseQueryRequest} 
var opts = {
  'xRequestedWith': xRequestedWith_example // {String} CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.dbBulkQuery(bulkDatabaseQueryRequest, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class dbBulkQueryExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DatabaseApi();
            var bulkDatabaseQueryRequest = new BulkDatabaseQueryRequest(); // BulkDatabaseQueryRequest | 
            var xRequestedWith = xRequestedWith_example;  // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests. (optional)  (default to null)

            try {
                // Execute bulk database queries
                BulkDatabaseQueryResponse result = apiInstance.dbBulkQuery(bulkDatabaseQueryRequest, xRequestedWith);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DatabaseApi.dbBulkQuery: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DatabaseApi();
$bulkDatabaseQueryRequest = ; // BulkDatabaseQueryRequest | 
$xRequestedWith = xRequestedWith_example; // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

try {
    $result = $api_instance->dbBulkQuery($bulkDatabaseQueryRequest, $xRequestedWith);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatabaseApi->dbBulkQuery: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DatabaseApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DatabaseApi->new();
my $bulkDatabaseQueryRequest = WWW::OPenAPIClient::Object::BulkDatabaseQueryRequest->new(); # BulkDatabaseQueryRequest | 
my $xRequestedWith = xRequestedWith_example; # String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

eval {
    my $result = $api_instance->dbBulkQuery(bulkDatabaseQueryRequest => $bulkDatabaseQueryRequest, xRequestedWith => $xRequestedWith);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatabaseApi->dbBulkQuery: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DatabaseApi()
bulkDatabaseQueryRequest =  # BulkDatabaseQueryRequest | 
xRequestedWith = xRequestedWith_example # String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests. (optional) (default to null)

try:
    # Execute bulk database queries
    api_response = api_instance.db_bulk_query(bulkDatabaseQueryRequest, xRequestedWith=xRequestedWith)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatabaseApi->dbBulkQuery: %s\n" % e)

extern crate DatabaseApi;

pub fn main() {
    let bulkDatabaseQueryRequest = ; // BulkDatabaseQueryRequest
    let xRequestedWith = xRequestedWith_example; // String

    let mut context = DatabaseApi::Context::default();
    let result = client.dbBulkQuery(bulkDatabaseQueryRequest, xRequestedWith, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DatabaseApi;

import java.io.File;
import java.util.*;

public class DatabaseApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DatabaseApi apiInstance = new DatabaseApi();
        BulkDatabaseStatsRequest bulkDatabaseStatsRequest = ; // BulkDatabaseStatsRequest | 
        String xRequestedWith = xRequestedWith_example; // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

        try {
            BulkDatabaseStatsResponse result = apiInstance.dbBulkStats(bulkDatabaseStatsRequest, xRequestedWith);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseApi#dbBulkStats");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkDatabaseStatsRequest bulkDatabaseStatsRequest = new BulkDatabaseStatsRequest(); // BulkDatabaseStatsRequest | 
final String xRequestedWith = new String(); // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

try {
    final result = await api_instance.dbBulkStats(bulkDatabaseStatsRequest, xRequestedWith);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->dbBulkStats: $e\n');
}

import org.openapitools.client.api.DatabaseApi;

public class DatabaseApiExample {
    public static void main(String[] args) {
        DatabaseApi apiInstance = new DatabaseApi();
        BulkDatabaseStatsRequest bulkDatabaseStatsRequest = ; // BulkDatabaseStatsRequest | 
        String xRequestedWith = xRequestedWith_example; // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

        try {
            BulkDatabaseStatsResponse result = apiInstance.dbBulkStats(bulkDatabaseStatsRequest, xRequestedWith);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DatabaseApi#dbBulkStats");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
DatabaseApi *apiInstance = [[DatabaseApi alloc] init];
BulkDatabaseStatsRequest *bulkDatabaseStatsRequest = ; // 
String *xRequestedWith = xRequestedWith_example; // CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests. (optional) (default to null)

// Get bulk database statistics
[apiInstance dbBulkStatsWith:bulkDatabaseStatsRequest
    xRequestedWith:xRequestedWith
              completionHandler: ^(BulkDatabaseStatsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.DatabaseApi()
var bulkDatabaseStatsRequest = ; // {BulkDatabaseStatsRequest} 
var opts = {
  'xRequestedWith': xRequestedWith_example // {String} CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.dbBulkStats(bulkDatabaseStatsRequest, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class dbBulkStatsExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DatabaseApi();
            var bulkDatabaseStatsRequest = new BulkDatabaseStatsRequest(); // BulkDatabaseStatsRequest | 
            var xRequestedWith = xRequestedWith_example;  // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests. (optional)  (default to null)

            try {
                // Get bulk database statistics
                BulkDatabaseStatsResponse result = apiInstance.dbBulkStats(bulkDatabaseStatsRequest, xRequestedWith);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DatabaseApi.dbBulkStats: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DatabaseApi();
$bulkDatabaseStatsRequest = ; // BulkDatabaseStatsRequest | 
$xRequestedWith = xRequestedWith_example; // String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

try {
    $result = $api_instance->dbBulkStats($bulkDatabaseStatsRequest, $xRequestedWith);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DatabaseApi->dbBulkStats: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DatabaseApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DatabaseApi->new();
my $bulkDatabaseStatsRequest = WWW::OPenAPIClient::Object::BulkDatabaseStatsRequest->new(); # BulkDatabaseStatsRequest | 
my $xRequestedWith = xRequestedWith_example; # String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests.

eval {
    my $result = $api_instance->dbBulkStats(bulkDatabaseStatsRequest => $bulkDatabaseStatsRequest, xRequestedWith => $xRequestedWith);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DatabaseApi->dbBulkStats: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DatabaseApi()
bulkDatabaseStatsRequest =  # BulkDatabaseStatsRequest | 
xRequestedWith = xRequestedWith_example # String | CSRF/XHR sentinel header. Must be exactly "XMLHttpRequest" for browser-initiated unsafe requests. (optional) (default to null)

try:
    # Get bulk database statistics
    api_response = api_instance.db_bulk_stats(bulkDatabaseStatsRequest, xRequestedWith=xRequestedWith)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DatabaseApi->dbBulkStats: %s\n" % e)

extern crate DatabaseApi;

pub fn main() {
    let bulkDatabaseStatsRequest = ; // BulkDatabaseStatsRequest
    let xRequestedWith = xRequestedWith_example; // String

    let mut context = DatabaseApi::Context::default();
    let result = client.dbBulkStats(bulkDatabaseStatsRequest, xRequestedWith, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.HealthApi;

import java.io.File;
import java.util.*;

public class HealthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        HealthApi apiInstance = new HealthApi();

        try {
            HealthResponse result = apiInstance.healthCheck();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#healthCheck");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.healthCheck();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->healthCheck: $e\n');
}

import org.openapitools.client.api.HealthApi;

public class HealthApiExample {
    public static void main(String[] args) {
        HealthApi apiInstance = new HealthApi();

        try {
            HealthResponse result = apiInstance.healthCheck();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#healthCheck");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
HealthApi *apiInstance = [[HealthApi alloc] init];

// Health check
[apiInstance healthCheckWithCompletionHandler: 
              ^(HealthResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.HealthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.healthCheck(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class healthCheckExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new HealthApi();

            try {
                // Health check
                HealthResponse result = apiInstance.healthCheck();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling HealthApi.healthCheck: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\HealthApi();

try {
    $result = $api_instance->healthCheck();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HealthApi->healthCheck: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::HealthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::HealthApi->new();

eval {
    my $result = $api_instance->healthCheck();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HealthApi->healthCheck: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.HealthApi()

try:
    # Health check
    api_response = api_instance.health_check()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HealthApi->healthCheck: %s\n" % e)

extern crate HealthApi;

pub fn main() {

    let mut context = HealthApi::Context::default();
    let result = client.healthCheck(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.HealthApi;

import java.io.File;
import java.util.*;

public class HealthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        HealthApi apiInstance = new HealthApi();

        try {
            HealthResponse result = apiInstance.healthLive();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#healthLive");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.healthLive();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->healthLive: $e\n');
}

import org.openapitools.client.api.HealthApi;

public class HealthApiExample {
    public static void main(String[] args) {
        HealthApi apiInstance = new HealthApi();

        try {
            HealthResponse result = apiInstance.healthLive();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#healthLive");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
HealthApi *apiInstance = [[HealthApi alloc] init];

// Liveness check
[apiInstance healthLiveWithCompletionHandler: 
              ^(HealthResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.HealthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.healthLive(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class healthLiveExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new HealthApi();

            try {
                // Liveness check
                HealthResponse result = apiInstance.healthLive();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling HealthApi.healthLive: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\HealthApi();

try {
    $result = $api_instance->healthLive();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HealthApi->healthLive: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::HealthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::HealthApi->new();

eval {
    my $result = $api_instance->healthLive();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HealthApi->healthLive: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.HealthApi()

try:
    # Liveness check
    api_response = api_instance.health_live()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HealthApi->healthLive: %s\n" % e)

extern crate HealthApi;

pub fn main() {

    let mut context = HealthApi::Context::default();
    let result = client.healthLive(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.HealthApi;

import java.io.File;
import java.util.*;

public class HealthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        HealthApi apiInstance = new HealthApi();

        try {
            HealthResponse result = apiInstance.healthReady();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#healthReady");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.healthReady();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->healthReady: $e\n');
}

import org.openapitools.client.api.HealthApi;

public class HealthApiExample {
    public static void main(String[] args) {
        HealthApi apiInstance = new HealthApi();

        try {
            HealthResponse result = apiInstance.healthReady();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#healthReady");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
HealthApi *apiInstance = [[HealthApi alloc] init];

// Readiness check
[apiInstance healthReadyWithCompletionHandler: 
              ^(HealthResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.HealthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.healthReady(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class healthReadyExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new HealthApi();

            try {
                // Readiness check
                HealthResponse result = apiInstance.healthReady();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling HealthApi.healthReady: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\HealthApi();

try {
    $result = $api_instance->healthReady();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HealthApi->healthReady: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::HealthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::HealthApi->new();

eval {
    my $result = $api_instance->healthReady();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HealthApi->healthReady: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.HealthApi()

try:
    # Readiness check
    api_response = api_instance.health_ready()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HealthApi->healthReady: %s\n" % e)

extern crate HealthApi;

pub fn main() {

    let mut context = HealthApi::Context::default();
    let result = client.healthReady(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.HealthApi;

import java.io.File;
import java.util.*;

public class HealthApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        HealthApi apiInstance = new HealthApi();

        try {
            PingResponse result = apiInstance.ping();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#ping");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.ping();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->ping: $e\n');
}

import org.openapitools.client.api.HealthApi;

public class HealthApiExample {
    public static void main(String[] args) {
        HealthApi apiInstance = new HealthApi();

        try {
            PingResponse result = apiInstance.ping();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#ping");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
HealthApi *apiInstance = [[HealthApi alloc] init];

// Ping server
[apiInstance pingWithCompletionHandler: 
              ^(PingResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.HealthApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.ping(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class pingExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new HealthApi();

            try {
                // Ping server
                PingResponse result = apiInstance.ping();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling HealthApi.ping: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\HealthApi();

try {
    $result = $api_instance->ping();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling HealthApi->ping: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::HealthApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::HealthApi->new();

eval {
    my $result = $api_instance->ping();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling HealthApi->ping: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.HealthApi()

try:
    # Ping server
    api_response = api_instance.ping()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HealthApi->ping: %s\n" % e)

extern crate HealthApi;

pub fn main() {

    let mut context = HealthApi::Context::default();
    let result = client.ping(&context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordExtractionApi;

import java.io.File;
import java.util.*;

public class KeywordExtractionApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordExtractionApi apiInstance = new KeywordExtractionApi();
        BatchKeywordExtractionRequest batchKeywordExtractionRequest = ; // BatchKeywordExtractionRequest | 

        try {
            BatchKeywordExtractionResponse result = apiInstance.keywordExtractBatch(batchKeywordExtractionRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordExtractionApi#keywordExtractBatch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BatchKeywordExtractionRequest batchKeywordExtractionRequest = new BatchKeywordExtractionRequest(); // BatchKeywordExtractionRequest | 

try {
    final result = await api_instance.keywordExtractBatch(batchKeywordExtractionRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordExtractBatch: $e\n');
}

import org.openapitools.client.api.KeywordExtractionApi;

public class KeywordExtractionApiExample {
    public static void main(String[] args) {
        KeywordExtractionApi apiInstance = new KeywordExtractionApi();
        BatchKeywordExtractionRequest batchKeywordExtractionRequest = ; // BatchKeywordExtractionRequest | 

        try {
            BatchKeywordExtractionResponse result = apiInstance.keywordExtractBatch(batchKeywordExtractionRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordExtractionApi#keywordExtractBatch");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordExtractionApi *apiInstance = [[KeywordExtractionApi alloc] init];
BatchKeywordExtractionRequest *batchKeywordExtractionRequest = ; // 

// Batch keyword extraction
[apiInstance keywordExtractBatchWith:batchKeywordExtractionRequest
              completionHandler: ^(BatchKeywordExtractionResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordExtractionApi()
var batchKeywordExtractionRequest = ; // {BatchKeywordExtractionRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordExtractBatch(batchKeywordExtractionRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordExtractBatchExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordExtractionApi();
            var batchKeywordExtractionRequest = new BatchKeywordExtractionRequest(); // BatchKeywordExtractionRequest | 

            try {
                // Batch keyword extraction
                BatchKeywordExtractionResponse result = apiInstance.keywordExtractBatch(batchKeywordExtractionRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordExtractionApi.keywordExtractBatch: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordExtractionApi();
$batchKeywordExtractionRequest = ; // BatchKeywordExtractionRequest | 

try {
    $result = $api_instance->keywordExtractBatch($batchKeywordExtractionRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordExtractionApi->keywordExtractBatch: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordExtractionApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordExtractionApi->new();
my $batchKeywordExtractionRequest = WWW::OPenAPIClient::Object::BatchKeywordExtractionRequest->new(); # BatchKeywordExtractionRequest | 

eval {
    my $result = $api_instance->keywordExtractBatch(batchKeywordExtractionRequest => $batchKeywordExtractionRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordExtractionApi->keywordExtractBatch: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordExtractionApi()
batchKeywordExtractionRequest =  # BatchKeywordExtractionRequest | 

try:
    # Batch keyword extraction
    api_response = api_instance.keyword_extract_batch(batchKeywordExtractionRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordExtractionApi->keywordExtractBatch: %s\n" % e)

extern crate KeywordExtractionApi;

pub fn main() {
    let batchKeywordExtractionRequest = ; // BatchKeywordExtractionRequest

    let mut context = KeywordExtractionApi::Context::default();
    let result = client.keywordExtractBatch(batchKeywordExtractionRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordExtractionApi;

import java.io.File;
import java.util.*;

public class KeywordExtractionApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordExtractionApi apiInstance = new KeywordExtractionApi();
        URI url = url_example; // URI | 
        UUID keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            'String' result = apiInstance.keywordExtractStream(url, keywordSetId, httpPersonaId, dnsPersonaId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordExtractionApi#keywordExtractStream");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final URI url = new URI(); // URI | 
final UUID keywordSetId = new UUID(); // UUID | 
final UUID httpPersonaId = new UUID(); // UUID | 
final UUID dnsPersonaId = new UUID(); // UUID | 

try {
    final result = await api_instance.keywordExtractStream(url, keywordSetId, httpPersonaId, dnsPersonaId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordExtractStream: $e\n');
}

import org.openapitools.client.api.KeywordExtractionApi;

public class KeywordExtractionApiExample {
    public static void main(String[] args) {
        KeywordExtractionApi apiInstance = new KeywordExtractionApi();
        URI url = url_example; // URI | 
        UUID keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            'String' result = apiInstance.keywordExtractStream(url, keywordSetId, httpPersonaId, dnsPersonaId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordExtractionApi#keywordExtractStream");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordExtractionApi *apiInstance = [[KeywordExtractionApi alloc] init];
URI *url = url_example; //  (default to null)
UUID *keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
UUID *httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (optional) (default to null)
UUID *dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (optional) (default to null)

// Stream keyword extraction
[apiInstance keywordExtractStreamWith:url
    keywordSetId:keywordSetId
    httpPersonaId:httpPersonaId
    dnsPersonaId:dnsPersonaId
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordExtractionApi()
var url = url_example; // {URI} 
var keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var opts = {
  'httpPersonaId': 38400000-8cf0-11bd-b23e-10b96e4ef00d, // {UUID} 
  'dnsPersonaId': 38400000-8cf0-11bd-b23e-10b96e4ef00d // {UUID} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordExtractStream(url, keywordSetId, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordExtractStreamExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordExtractionApi();
            var url = url_example;  // URI |  (default to null)
            var keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (optional)  (default to null)
            var dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (optional)  (default to null)

            try {
                // Stream keyword extraction
                'String' result = apiInstance.keywordExtractStream(url, keywordSetId, httpPersonaId, dnsPersonaId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordExtractionApi.keywordExtractStream: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordExtractionApi();
$url = url_example; // URI | 
$keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->keywordExtractStream($url, $keywordSetId, $httpPersonaId, $dnsPersonaId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordExtractionApi->keywordExtractStream: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordExtractionApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordExtractionApi->new();
my $url = url_example; # URI | 
my $keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->keywordExtractStream(url => $url, keywordSetId => $keywordSetId, httpPersonaId => $httpPersonaId, dnsPersonaId => $dnsPersonaId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordExtractionApi->keywordExtractStream: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordExtractionApi()
url = url_example # URI |  (default to null)
keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (optional) (default to null)
dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (optional) (default to null)

try:
    # Stream keyword extraction
    api_response = api_instance.keyword_extract_stream(url, keywordSetId, httpPersonaId=httpPersonaId, dnsPersonaId=dnsPersonaId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordExtractionApi->keywordExtractStream: %s\n" % e)

extern crate KeywordExtractionApi;

pub fn main() {
    let url = url_example; // URI
    let keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let httpPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let dnsPersonaId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = KeywordExtractionApi::Context::default();
    let result = client.keywordExtractStream(url, keywordSetId, httpPersonaId, dnsPersonaId, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordRulesApi;

import java.io.File;
import java.util.*;

public class KeywordRulesApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordRulesApi apiInstance = new KeywordRulesApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        UUID keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        KeywordRuleType ruleType = ; // KeywordRuleType | 
        String category = category_example; // String | 
        Boolean isCaseSensitive = true; // Boolean | 
        String pattern = pattern_example; // String | 

        try {
            array[KeywordRuleDTO] result = apiInstance.keywordRulesQuery(limit, offset, keywordSetId, ruleType, category, isCaseSensitive, pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordRulesApi#keywordRulesQuery");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer limit = new Integer(); // Integer | 
final Integer offset = new Integer(); // Integer | 
final UUID keywordSetId = new UUID(); // UUID | 
final KeywordRuleType ruleType = new KeywordRuleType(); // KeywordRuleType | 
final String category = new String(); // String | 
final Boolean isCaseSensitive = new Boolean(); // Boolean | 
final String pattern = new String(); // String | 

try {
    final result = await api_instance.keywordRulesQuery(limit, offset, keywordSetId, ruleType, category, isCaseSensitive, pattern);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordRulesQuery: $e\n');
}

import org.openapitools.client.api.KeywordRulesApi;

public class KeywordRulesApiExample {
    public static void main(String[] args) {
        KeywordRulesApi apiInstance = new KeywordRulesApi();
        Integer limit = 56; // Integer | 
        Integer offset = 56; // Integer | 
        UUID keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        KeywordRuleType ruleType = ; // KeywordRuleType | 
        String category = category_example; // String | 
        Boolean isCaseSensitive = true; // Boolean | 
        String pattern = pattern_example; // String | 

        try {
            array[KeywordRuleDTO] result = apiInstance.keywordRulesQuery(limit, offset, keywordSetId, ruleType, category, isCaseSensitive, pattern);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordRulesApi#keywordRulesQuery");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordRulesApi *apiInstance = [[KeywordRulesApi alloc] init];
Integer *limit = 56; //  (optional) (default to 50)
Integer *offset = 56; //  (optional) (default to 0)
UUID *keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (optional) (default to null)
KeywordRuleType *ruleType = ; //  (optional) (default to null)
String *category = category_example; //  (optional) (default to null)
Boolean *isCaseSensitive = true; //  (optional) (default to null)
String *pattern = pattern_example; //  (optional) (default to null)

// Query keyword rules
[apiInstance keywordRulesQueryWith:limit
    offset:offset
    keywordSetId:keywordSetId
    ruleType:ruleType
    category:category
    isCaseSensitive:isCaseSensitive
    pattern:pattern
              completionHandler: ^(array[KeywordRuleDTO] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordRulesApi()
var opts = {
  'limit': 56, // {Integer} 
  'offset': 56, // {Integer} 
  'keywordSetId': 38400000-8cf0-11bd-b23e-10b96e4ef00d, // {UUID} 
  'ruleType': , // {KeywordRuleType} 
  'category': category_example, // {String} 
  'isCaseSensitive': true, // {Boolean} 
  'pattern': pattern_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordRulesQuery(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordRulesQueryExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordRulesApi();
            var limit = 56;  // Integer |  (optional)  (default to 50)
            var offset = 56;  // Integer |  (optional)  (default to 0)
            var keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (optional)  (default to null)
            var ruleType = new KeywordRuleType(); // KeywordRuleType |  (optional)  (default to null)
            var category = category_example;  // String |  (optional)  (default to null)
            var isCaseSensitive = true;  // Boolean |  (optional)  (default to null)
            var pattern = pattern_example;  // String |  (optional)  (default to null)

            try {
                // Query keyword rules
                array[KeywordRuleDTO] result = apiInstance.keywordRulesQuery(limit, offset, keywordSetId, ruleType, category, isCaseSensitive, pattern);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordRulesApi.keywordRulesQuery: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordRulesApi();
$limit = 56; // Integer | 
$offset = 56; // Integer | 
$keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$ruleType = ; // KeywordRuleType | 
$category = category_example; // String | 
$isCaseSensitive = true; // Boolean | 
$pattern = pattern_example; // String | 

try {
    $result = $api_instance->keywordRulesQuery($limit, $offset, $keywordSetId, $ruleType, $category, $isCaseSensitive, $pattern);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordRulesApi->keywordRulesQuery: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordRulesApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordRulesApi->new();
my $limit = 56; # Integer | 
my $offset = 56; # Integer | 
my $keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $ruleType = ; # KeywordRuleType | 
my $category = category_example; # String | 
my $isCaseSensitive = true; # Boolean | 
my $pattern = pattern_example; # String | 

eval {
    my $result = $api_instance->keywordRulesQuery(limit => $limit, offset => $offset, keywordSetId => $keywordSetId, ruleType => $ruleType, category => $category, isCaseSensitive => $isCaseSensitive, pattern => $pattern);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordRulesApi->keywordRulesQuery: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordRulesApi()
limit = 56 # Integer |  (optional) (default to 50)
offset = 56 # Integer |  (optional) (default to 0)
keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (optional) (default to null)
ruleType =  # KeywordRuleType |  (optional) (default to null)
category = category_example # String |  (optional) (default to null)
isCaseSensitive = true # Boolean |  (optional) (default to null)
pattern = pattern_example # String |  (optional) (default to null)

try:
    # Query keyword rules
    api_response = api_instance.keyword_rules_query(limit=limit, offset=offset, keywordSetId=keywordSetId, ruleType=ruleType, category=category, isCaseSensitive=isCaseSensitive, pattern=pattern)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordRulesApi->keywordRulesQuery: %s\n" % e)

extern crate KeywordRulesApi;

pub fn main() {
    let limit = 56; // Integer
    let offset = 56; // Integer
    let keywordSetId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let ruleType = ; // KeywordRuleType
    let category = category_example; // String
    let isCaseSensitive = true; // Boolean
    let pattern = pattern_example; // String

    let mut context = KeywordRulesApi::Context::default();
    let result = client.keywordRulesQuery(limit, offset, keywordSetId, ruleType, category, isCaseSensitive, pattern, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordSetsApi;

import java.io.File;
import java.util.*;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        CreateKeywordSetRequest createKeywordSetRequest = ; // CreateKeywordSetRequest | 

        try {
            KeywordSetResponse result = apiInstance.keywordSetsCreate(createKeywordSetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsCreate");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateKeywordSetRequest createKeywordSetRequest = new CreateKeywordSetRequest(); // CreateKeywordSetRequest | 

try {
    final result = await api_instance.keywordSetsCreate(createKeywordSetRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordSetsCreate: $e\n');
}

import org.openapitools.client.api.KeywordSetsApi;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        CreateKeywordSetRequest createKeywordSetRequest = ; // CreateKeywordSetRequest | 

        try {
            KeywordSetResponse result = apiInstance.keywordSetsCreate(createKeywordSetRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsCreate");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordSetsApi *apiInstance = [[KeywordSetsApi alloc] init];
CreateKeywordSetRequest *createKeywordSetRequest = ; // 

// Create keyword set
[apiInstance keywordSetsCreateWith:createKeywordSetRequest
              completionHandler: ^(KeywordSetResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordSetsApi()
var createKeywordSetRequest = ; // {CreateKeywordSetRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.keywordSetsCreate(createKeywordSetRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordSetsCreateExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordSetsApi();
            var createKeywordSetRequest = new CreateKeywordSetRequest(); // CreateKeywordSetRequest | 

            try {
                // Create keyword set
                KeywordSetResponse result = apiInstance.keywordSetsCreate(createKeywordSetRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordSetsApi.keywordSetsCreate: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordSetsApi();
$createKeywordSetRequest = ; // CreateKeywordSetRequest | 

try {
    $result = $api_instance->keywordSetsCreate($createKeywordSetRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling KeywordSetsApi->keywordSetsCreate: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordSetsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordSetsApi->new();
my $createKeywordSetRequest = WWW::OPenAPIClient::Object::CreateKeywordSetRequest->new(); # CreateKeywordSetRequest | 

eval {
    my $result = $api_instance->keywordSetsCreate(createKeywordSetRequest => $createKeywordSetRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling KeywordSetsApi->keywordSetsCreate: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordSetsApi()
createKeywordSetRequest =  # CreateKeywordSetRequest | 

try:
    # Create keyword set
    api_response = api_instance.keyword_sets_create(createKeywordSetRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling KeywordSetsApi->keywordSetsCreate: %s\n" % e)

extern crate KeywordSetsApi;

pub fn main() {
    let createKeywordSetRequest = ; // CreateKeywordSetRequest

    let mut context = KeywordSetsApi::Context::default();
    let result = client.keywordSetsCreate(createKeywordSetRequest, &context).wait();

    println!("{:?}", result);
}

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.KeywordSetsApi;

import java.io.File;
import java.util.*;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure API key authorization: cookieAuth
        ApiKeyAuth cookieAuth = (ApiKeyAuth) defaultClient.getAuthentication("cookieAuth");
        cookieAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //cookieAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        UUID setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.keywordSetsDelete(setId);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsDelete");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UUID setId = new UUID(); // UUID | 

try {
    final result = await api_instance.keywordSetsDelete(setId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->keywordSetsDelete: $e\n');
}

import org.openapitools.client.api.KeywordSetsApi;

public class KeywordSetsApiExample {
    public static void main(String[] args) {
        KeywordSetsApi apiInstance = new KeywordSetsApi();
        UUID setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.keywordSetsDelete(setId);
        } catch (ApiException e) {
            System.err.println("Exception when calling KeywordSetsApi#keywordSetsDelete");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure API key authorization: (authentication scheme: cookieAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"domainflow_session"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"domainflow_session"];


// Create an instance of the API class
KeywordSetsApi *apiInstance = [[KeywordSetsApi alloc] init];
UUID *setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

// Delete keyword set
[apiInstance keywordSetsDeleteWith:setId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DomainFlowApi = require('domain_flow_api');
var defaultClient = DomainFlowApi.ApiClient.instance;

// Configure API key authorization: cookieAuth
var cookieAuth = defaultClient.authentications['cookieAuth'];
cookieAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//cookieAuth.apiKeyPrefix['domainflow_session'] = "Token";

// Create an instance of the API class
var api = new DomainFlowApi.KeywordSetsApi()
var setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.keywordSetsDelete(setId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class keywordSetsDeleteExample
    {
        public void main()
        {
            // Configure API key authorization: cookieAuth
            Configuration.Default.ApiKey.Add("domainflow_session", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("domainflow_session", "Bearer");

            // Create an instance of the API class
            var apiInstance = new KeywordSetsApi();
            var setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                // Delete keyword set
                apiInstance.keywordSetsDelete(setId);
            } catch (Exception e) {
                Debug.Print("Exception when calling KeywordSetsApi.keywordSetsDelete: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure API key authorization: cookieAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('domainflow_session', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('domainflow_session', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\KeywordSetsApi();
$setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $api_instance->keywordSetsDelete($setId);
} catch (Exception $e) {
    echo 'Exception when calling KeywordSetsApi->keywordSetsDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::KeywordSetsApi;

# Configure API key authorization: cookieAuth
$WWW::OPenAPIClient::Configuration::api_key->{'domainflow_session'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'domainflow_session'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::KeywordSetsApi->new();
my $setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    $api_instance->keywordSetsDelete(setId => $setId);
};
if ($@) {
    warn "Exception when calling KeywordSetsApi->keywordSetsDelete: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: cookieAuth
openapi_client.configuration.api_key['domainflow_session'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['domainflow_session'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.KeywordSetsApi()
setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    # Delete keyword set
    api_instance.keyword_sets_delete(setId)
except ApiException as e:
    print("Exception when calling KeywordSetsApi->keywordSetsDelete: %s\n" % e)

extern crate KeywordSetsApi;

pub fn main() {
    let setId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = KeywordSetsApi::Context::default();
    let result = client.keywordSetsDelete(setId, &context).wait();

    println!("{:?}", result);
}